Revert "[fidl][llcpp] Generate llcpp bindings at build time"
This reverts commit 85fff8a35408917585010d2036b09b39a86952d8.
Reason for revert: <INSERT REASONING HERE>
Original change's description:
> [fidl][llcpp] Generate llcpp bindings at build time
>
> This removes the pre-building of llcpp bindings and instead builds them
> as required at build time. This updates the zircon fidl llcpp build
> rules to use fidlgen_llcpp rather than just pointing to the prebuilts.
>
> Bug: 3240
>
> Change-Id: I0902cdce98ddc460bd3bf49ff6786608c029b7da
TBR=phosek@chromium.org,pylaligand@google.com,mcgrathr@google.com,ianloic@google.com,pascallouis@google.com
Change-Id: I4e4b3db35cd4ecdee9233c910ed38ce0e5fa16ed
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: 3240
diff --git a/BUILD.gn b/BUILD.gn
index 45e5775..a3108c2 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -453,6 +453,7 @@
group("default") {
testonly = true
deps = [
+ ":build_time_checks",
"//build:tests",
"//build/images:packages",
"//sdk",
@@ -486,6 +487,11 @@
public_deps = universe_package_labels
}
+group("build_time_checks") {
+ testonly = true
+ deps = [ "//tools/fidlgen_llcpp_zircon:validate" ]
+}
+
group("recovery_image") {
# TODO(fxbug.dev/37792): Investigate use of testonly here.
testonly = true
diff --git a/docs/development/languages/fidl/CONTRIBUTING.md b/docs/development/languages/fidl/CONTRIBUTING.md
index 810a40c..8672c88 100644
--- a/docs/development/languages/fidl/CONTRIBUTING.md
+++ b/docs/development/languages/fidl/CONTRIBUTING.md
@@ -440,6 +440,11 @@
| dart fidlgen goldens | fx exec $FUCHSIA_DIR/topaz/bin/fidlgen_dart/regen.sh | garnet/go/src/fidl/compiler/backend/goldens | topaz/bin/fidlgen_dart/goldens |
| dangerous identifiers | garnet/tests/fidl-dangerous-identifiers/generate.py | garnet/tests/fidl-dangerous-identifiers/dangerous_identifiers.txt | garnet/tests/fidl-dangerous-identifiers/cpp/ garnet/tests/fidl-dangerous-identifiers/fidl/ |
| regen third party go | fx exec $FUCHSIA_DIR/third_party/go/regen-fidl | | |
+| regen c-llcpp interop test bindings | fx exec $FUCHSIA_DIR/zircon/system/utest/fidl-llcpp-interop/gen_llcpp.sh | zircon/system/utest/fidl-llcpp-interop/*.test.fidl | zircon/system/utest/fidl-llcpp-interop/generated/ |
+| regen llcpp fidl::Bind test bindings | fx exec $FUCHSIA_DIR/zircon/system/utest/fidl/gen.sh | zircon/system/utest/fidl/llcpp.test.fidl | zircon/system/utest/fidl/generated/ |
+| regen fidl-async test bindings | fx exec $FUCHSIA_DIR/zircon/system/ulib/fidl-async/test/gen_llcpp.sh | zircon/system/ulib/fidl-async/test/simple.test.fidl | zircon/system/ulib/fidl-async/test/generated/ |
+| regen llcpp service test bindings | fx exec $FUCHSIA_DIR/zircon/system/utest/service/gen_llcpp.sh | zircon/system/utest/service/test.test.fidl | zircon/system/utest/service/generated/ |
+| checked in production llcpp bindings | fx build -k 0 tools/fidlgen_llcpp_zircon:update | FIDL definitions in zircon/system/fidl/ | "gen/" folder relative to the corresponding FIDL definition |
## Debugging (host)
diff --git a/docs/development/languages/fidl/reference/compiler.md b/docs/development/languages/fidl/reference/compiler.md
index 0248d3ed..2683121 100644
--- a/docs/development/languages/fidl/reference/compiler.md
+++ b/docs/development/languages/fidl/reference/compiler.md
@@ -375,11 +375,9 @@
my_struct_fields, 1u, 32u, "mylibrary/MyStruct"));
```
-Coding tables for FIDL libraries in `//sdk/fidl` are generated into the out directory under
-`fidling/gen/sdk/fidl/LIBRARY/LIBRARY.fidl.tables.c`. For example
-`out/default/fidling/gen/sdk/fuchsia.sys/fuchsia.sys.fidl.tables.c`. The [README][coding-readme]
-gives additional context. The `fidl_type_t` definitions (such as for `FidlCodedStruct`) can be found
-in [internal.h][internal].
+An example of generated coding tables can be found in [extra_messages.c][extra_messages]. The
+[README][coding-readme] gives additional context. The `fidl_type_t` definitions (such as for
+`FidlCodedStruct`) can be found in [internal.h][internal].
### Glossary
@@ -498,6 +496,7 @@
anonymous [`Name`](#name)s.
<!-- xrefs -->
+[extra_messages]: /zircon/system/utest/fidl/generated/extra_messages.c
[internal]: /zircon/system/ulib/fidl/include/lib/fidl/internal.h
[layout-attr]: /docs/development/languages/fidl/reference/attributes.md#layout_layout
[fidlgen]: /garnet/go/src/fidl/compiler/backend
diff --git a/docs/development/languages/fidl/tutorial/tutorial-llcpp.md b/docs/development/languages/fidl/tutorial/tutorial-llcpp.md
index 90d3779..5017154 100644
--- a/docs/development/languages/fidl/tutorial/tutorial-llcpp.md
+++ b/docs/development/languages/fidl/tutorial/tutorial-llcpp.md
@@ -33,9 +33,14 @@
`"//sdk/fidl/fuchsia.math:fuchsia.math_llcpp"`, and the bindings code
will be automatically generated as part of the build.
* **Code is inside `zircon/`:**
- Add a GN dependency of the form: `"$zx/system/fidl/[library-name]:llcpp"`,
- e.g. `"$zx/system/fidl/fuchsia-mem:llcpp"`, and the bindings code will be
- automatically generated as part of the build.
+ Add a GN dependency of the form: `"$zx/system/fidl/[library-name]:llcpp"`.
+ Run a special [command](/tools/fidlgen_llcpp_zircon/README.md) which
+ extracts the set of FIDL libraries used through LLCPP in Zircon, and builds
+ and runs the code generator during the Fuchsia build phase. The generated
+ code is placed in a `gen` folder next to the corresponding FIDL definition,
+ and has to be checked into source control
+ ([example](/zircon/system/fidl/fuchsia-io/gen/llcpp)). Whenever the FIDL
+ library changes, re-run the command to update the checked in bindings.
## Preliminary Concepts
diff --git a/garnet/packages/tools/BUILD.gn b/garnet/packages/tools/BUILD.gn
index 57e5166..44136ef 100644
--- a/garnet/packages/tools/BUILD.gn
+++ b/garnet/packages/tools/BUILD.gn
@@ -32,6 +32,7 @@
public_deps = [
":gidl",
"//garnet/go/src/fidl",
+ "//tools/fidlgen_llcpp_zircon",
]
}
diff --git a/sdk/fidl/fuchsia.input.report/gen/llcpp/fidl.cc b/sdk/fidl/fuchsia.input.report/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..7849be7
--- /dev/null
+++ b/sdk/fidl/fuchsia.input.report/gen/llcpp/fidl.cc
@@ -0,0 +1,805 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/input/report/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace input {
+namespace report {
+
+::llcpp::fuchsia::input::report::SensorReport::Builder SensorReport::Build() {
+ return SensorReport::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::SensorReport::Builder::set_values(::fidl::VectorView<int64_t>* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::SensorDescriptor::Builder SensorDescriptor::Build() {
+ return SensorDescriptor::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::SensorDescriptor::Builder::set_values(::fidl::VectorView<::llcpp::fuchsia::input::report::SensorAxis>* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::MouseDescriptor::Builder MouseDescriptor::Build() {
+ return MouseDescriptor::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::MouseDescriptor::Builder::set_movement_x(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::MouseDescriptor::Builder::set_movement_y(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::MouseDescriptor::Builder::set_scroll_v(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::MouseDescriptor::Builder::set_scroll_h(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::MouseDescriptor::Builder::set_buttons(::fidl::VectorView<uint8_t>* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::ContactDescriptor::Builder ContactDescriptor::Build() {
+ return ContactDescriptor::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::ContactDescriptor::Builder::set_position_x(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactDescriptor::Builder::set_position_y(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactDescriptor::Builder::set_pressure(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactDescriptor::Builder::set_contact_width(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactDescriptor::Builder::set_contact_height(::llcpp::fuchsia::input::report::Axis* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::TouchDescriptor::Builder TouchDescriptor::Build() {
+ return TouchDescriptor::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::TouchDescriptor::Builder::set_contacts(::fidl::VectorView<::llcpp::fuchsia::input::report::ContactDescriptor>* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::TouchDescriptor::Builder::set_max_contacts(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::TouchDescriptor::Builder::set_touch_type(::llcpp::fuchsia::input::report::TouchType* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::MouseReport::Builder MouseReport::Build() {
+ return MouseReport::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::MouseReport::Builder::set_movement_x(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::MouseReport::Builder::set_movement_y(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::MouseReport::Builder::set_scroll_v(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::MouseReport::Builder::set_scroll_h(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::MouseReport::Builder::set_pressed_buttons(::fidl::VectorView<uint8_t>* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::DeviceDescriptor::Builder DeviceDescriptor::Build() {
+ return DeviceDescriptor::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::DeviceDescriptor::Builder::set_device_info(::llcpp::fuchsia::input::report::DeviceInfo* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::DeviceDescriptor::Builder::set_mouse(::llcpp::fuchsia::input::report::MouseDescriptor* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::DeviceDescriptor::Builder::set_sensor(::llcpp::fuchsia::input::report::SensorDescriptor* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::DeviceDescriptor::Builder::set_touch(::llcpp::fuchsia::input::report::TouchDescriptor* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::ContactReport::Builder ContactReport::Build() {
+ return ContactReport::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::ContactReport::Builder::set_contact_id(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactReport::Builder::set_position_x(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactReport::Builder::set_position_y(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactReport::Builder::set_pressure(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactReport::Builder::set_contact_width(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::ContactReport::Builder::set_contact_height(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[6 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 6) {
+ max_ordinal_ = 6;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::TouchReport::Builder TouchReport::Build() {
+ return TouchReport::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::TouchReport::Builder::set_contacts(::fidl::VectorView<::llcpp::fuchsia::input::report::ContactReport>* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::input::report::InputReport::Builder InputReport::Build() {
+ return InputReport::Builder();
+}
+
+auto ::llcpp::fuchsia::input::report::InputReport::Builder::set_event_time(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::InputReport::Builder::set_mouse(::llcpp::fuchsia::input::report::MouseReport* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::InputReport::Builder::set_trace_id(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::InputReport::Builder::set_sensor(::llcpp::fuchsia::input::report::SensorReport* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::input::report::InputReport::Builder::set_touch(::llcpp::fuchsia::input::report::TouchReport* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kInputDevice_GetReportsEvent_Ordinal = 0x49e5124900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kInputDevice_GetReportsEvent_GenOrdinal = 0x2188910c9bac05aclu;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetReportsEventRequestTable;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetReportsEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetReportsEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kInputDevice_GetReports_Ordinal = 0x28a404a100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kInputDevice_GetReports_GenOrdinal = 0x5ba2344d51c69c2blu;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetReportsRequestTable;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetReportsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetReportsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kInputDevice_GetDescriptor_Ordinal = 0x5456d97300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kInputDevice_GetDescriptor_GenOrdinal = 0x3d76420f2ff8ad32lu;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetDescriptorRequestTable;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetDescriptorResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetDescriptorResponseTable;
+
+} // namespace
+template <>
+InputDevice::ResultOf::GetReportsEvent_Impl<InputDevice::GetReportsEventResponse>::GetReportsEvent_Impl(zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportsEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportsEventRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportsEventRequest));
+ ::fidl::DecodedMessage<GetReportsEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ InputDevice::InPlace::GetReportsEvent(std::move(_client_end), Super::response_buffer()));
+}
+
+InputDevice::ResultOf::GetReportsEvent InputDevice::SyncClient::GetReportsEvent() {
+ return ResultOf::GetReportsEvent(zx::unowned_channel(this->channel_));
+}
+
+InputDevice::ResultOf::GetReportsEvent InputDevice::Call::GetReportsEvent(zx::unowned_channel _client_end) {
+ return ResultOf::GetReportsEvent(std::move(_client_end));
+}
+
+template <>
+InputDevice::UnownedResultOf::GetReportsEvent_Impl<InputDevice::GetReportsEventResponse>::GetReportsEvent_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetReportsEventRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetReportsEventRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetReportsEventRequest));
+ ::fidl::DecodedMessage<GetReportsEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ InputDevice::InPlace::GetReportsEvent(std::move(_client_end), std::move(_response_buffer)));
+}
+
+InputDevice::UnownedResultOf::GetReportsEvent InputDevice::SyncClient::GetReportsEvent(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportsEvent(zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+InputDevice::UnownedResultOf::GetReportsEvent InputDevice::Call::GetReportsEvent(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportsEvent(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<InputDevice::GetReportsEventResponse> InputDevice::InPlace::GetReportsEvent(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetReportsEventRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetReportsEventRequest> params(std::move(_request_buffer));
+ InputDevice::SetTransactionHeaderFor::GetReportsEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<InputDevice::GetReportsEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportsEventRequest, GetReportsEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<InputDevice::GetReportsEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+InputDevice::ResultOf::GetReports_Impl<InputDevice::GetReportsResponse>::GetReports_Impl(zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportsRequest));
+ ::fidl::DecodedMessage<GetReportsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ InputDevice::InPlace::GetReports(std::move(_client_end), Super::response_buffer()));
+}
+
+InputDevice::ResultOf::GetReports InputDevice::SyncClient::GetReports() {
+ return ResultOf::GetReports(zx::unowned_channel(this->channel_));
+}
+
+InputDevice::ResultOf::GetReports InputDevice::Call::GetReports(zx::unowned_channel _client_end) {
+ return ResultOf::GetReports(std::move(_client_end));
+}
+
+template <>
+InputDevice::UnownedResultOf::GetReports_Impl<InputDevice::GetReportsResponse>::GetReports_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetReportsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetReportsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetReportsRequest));
+ ::fidl::DecodedMessage<GetReportsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ InputDevice::InPlace::GetReports(std::move(_client_end), std::move(_response_buffer)));
+}
+
+InputDevice::UnownedResultOf::GetReports InputDevice::SyncClient::GetReports(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReports(zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+InputDevice::UnownedResultOf::GetReports InputDevice::Call::GetReports(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReports(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<InputDevice::GetReportsResponse> InputDevice::InPlace::GetReports(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetReportsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetReportsRequest> params(std::move(_request_buffer));
+ InputDevice::SetTransactionHeaderFor::GetReportsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<InputDevice::GetReportsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportsRequest, GetReportsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<InputDevice::GetReportsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+InputDevice::ResultOf::GetDescriptor_Impl<InputDevice::GetDescriptorResponse>::GetDescriptor_Impl(zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDescriptorRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDescriptorRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDescriptorRequest));
+ ::fidl::DecodedMessage<GetDescriptorRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ InputDevice::InPlace::GetDescriptor(std::move(_client_end), Super::response_buffer()));
+}
+
+InputDevice::ResultOf::GetDescriptor InputDevice::SyncClient::GetDescriptor() {
+ return ResultOf::GetDescriptor(zx::unowned_channel(this->channel_));
+}
+
+InputDevice::ResultOf::GetDescriptor InputDevice::Call::GetDescriptor(zx::unowned_channel _client_end) {
+ return ResultOf::GetDescriptor(std::move(_client_end));
+}
+
+template <>
+InputDevice::UnownedResultOf::GetDescriptor_Impl<InputDevice::GetDescriptorResponse>::GetDescriptor_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDescriptorRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDescriptorRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDescriptorRequest));
+ ::fidl::DecodedMessage<GetDescriptorRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ InputDevice::InPlace::GetDescriptor(std::move(_client_end), std::move(_response_buffer)));
+}
+
+InputDevice::UnownedResultOf::GetDescriptor InputDevice::SyncClient::GetDescriptor(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDescriptor(zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+InputDevice::UnownedResultOf::GetDescriptor InputDevice::Call::GetDescriptor(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDescriptor(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<InputDevice::GetDescriptorResponse> InputDevice::InPlace::GetDescriptor(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDescriptorRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDescriptorRequest> params(std::move(_request_buffer));
+ InputDevice::SetTransactionHeaderFor::GetDescriptorRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<InputDevice::GetDescriptorResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDescriptorRequest, GetDescriptorResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<InputDevice::GetDescriptorResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool InputDevice::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kInputDevice_GetReportsEvent_Ordinal:
+ case kInputDevice_GetReportsEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportsEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetReportsEvent(
+ Interface::GetReportsEventCompleter::Sync(txn));
+ return true;
+ }
+ case kInputDevice_GetReports_Ordinal:
+ case kInputDevice_GetReports_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetReports(
+ Interface::GetReportsCompleter::Sync(txn));
+ return true;
+ }
+ case kInputDevice_GetDescriptor_Ordinal:
+ case kInputDevice_GetDescriptor_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDescriptorRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDescriptor(
+ Interface::GetDescriptorCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool InputDevice::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void InputDevice::Interface::GetReportsEventCompleterBase::Reply(int32_t status, ::zx::event event) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportsEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetReportsEventResponse*>(_write_bytes);
+ InputDevice::SetTransactionHeaderFor::GetReportsEventResponse(
+ ::fidl::DecodedMessage<GetReportsEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportsEventResponse::PrimarySize,
+ GetReportsEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.event = std::move(event);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportsEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetReportsEventResponse>(std::move(_response_bytes)));
+}
+
+void InputDevice::Interface::GetReportsEventCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event event) {
+ if (_buffer.capacity() < GetReportsEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetReportsEventResponse*>(_buffer.data());
+ InputDevice::SetTransactionHeaderFor::GetReportsEventResponse(
+ ::fidl::DecodedMessage<GetReportsEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportsEventResponse::PrimarySize,
+ GetReportsEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.event = std::move(event);
+ _buffer.set_actual(sizeof(GetReportsEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetReportsEventResponse>(std::move(_buffer)));
+}
+
+void InputDevice::Interface::GetReportsEventCompleterBase::Reply(::fidl::DecodedMessage<GetReportsEventResponse> params) {
+ InputDevice::SetTransactionHeaderFor::GetReportsEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void InputDevice::Interface::GetReportsCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::input::report::InputReport> reports) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetReportsResponse _response = {};
+ InputDevice::SetTransactionHeaderFor::GetReportsResponse(
+ ::fidl::DecodedMessage<GetReportsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportsResponse::PrimarySize,
+ GetReportsResponse::PrimarySize)));
+ _response.reports = std::move(reports);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void InputDevice::Interface::GetReportsCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::input::report::InputReport> reports) {
+ if (_buffer.capacity() < GetReportsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetReportsResponse _response = {};
+ InputDevice::SetTransactionHeaderFor::GetReportsResponse(
+ ::fidl::DecodedMessage<GetReportsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportsResponse::PrimarySize,
+ GetReportsResponse::PrimarySize)));
+ _response.reports = std::move(reports);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void InputDevice::Interface::GetReportsCompleterBase::Reply(::fidl::DecodedMessage<GetReportsResponse> params) {
+ InputDevice::SetTransactionHeaderFor::GetReportsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void InputDevice::Interface::GetDescriptorCompleterBase::Reply(::llcpp::fuchsia::input::report::DeviceDescriptor descriptor) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDescriptorResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetDescriptorResponse _response = {};
+ InputDevice::SetTransactionHeaderFor::GetDescriptorResponse(
+ ::fidl::DecodedMessage<GetDescriptorResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDescriptorResponse::PrimarySize,
+ GetDescriptorResponse::PrimarySize)));
+ _response.descriptor = std::move(descriptor);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void InputDevice::Interface::GetDescriptorCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::input::report::DeviceDescriptor descriptor) {
+ if (_buffer.capacity() < GetDescriptorResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDescriptorResponse _response = {};
+ InputDevice::SetTransactionHeaderFor::GetDescriptorResponse(
+ ::fidl::DecodedMessage<GetDescriptorResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDescriptorResponse::PrimarySize,
+ GetDescriptorResponse::PrimarySize)));
+ _response.descriptor = std::move(descriptor);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void InputDevice::Interface::GetDescriptorCompleterBase::Reply(::fidl::DecodedMessage<GetDescriptorResponse> params) {
+ InputDevice::SetTransactionHeaderFor::GetDescriptorResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void InputDevice::SetTransactionHeaderFor::GetReportsEventRequest(const ::fidl::DecodedMessage<InputDevice::GetReportsEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kInputDevice_GetReportsEvent_Ordinal);
+}
+void InputDevice::SetTransactionHeaderFor::GetReportsEventResponse(const ::fidl::DecodedMessage<InputDevice::GetReportsEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kInputDevice_GetReportsEvent_Ordinal);
+}
+
+void InputDevice::SetTransactionHeaderFor::GetReportsRequest(const ::fidl::DecodedMessage<InputDevice::GetReportsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kInputDevice_GetReports_Ordinal);
+}
+void InputDevice::SetTransactionHeaderFor::GetReportsResponse(const ::fidl::DecodedMessage<InputDevice::GetReportsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kInputDevice_GetReports_Ordinal);
+}
+
+void InputDevice::SetTransactionHeaderFor::GetDescriptorRequest(const ::fidl::DecodedMessage<InputDevice::GetDescriptorRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kInputDevice_GetDescriptor_Ordinal);
+}
+void InputDevice::SetTransactionHeaderFor::GetDescriptorResponse(const ::fidl::DecodedMessage<InputDevice::GetDescriptorResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kInputDevice_GetDescriptor_Ordinal);
+}
+
+} // namespace report
+} // namespace input
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/sdk/fidl/fuchsia.input.report/gen/llcpp/include/fuchsia/input/report/llcpp/fidl.h b/sdk/fidl/fuchsia.input.report/gen/llcpp/include/fuchsia/input/report/llcpp/fidl.h
new file mode 100644
index 0000000..9f9811b
--- /dev/null
+++ b/sdk/fidl/fuchsia.input.report/gen/llcpp/include/fuchsia/input/report/llcpp/fidl.h
@@ -0,0 +1,1749 @@
+// 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/event.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace input {
+namespace report {
+
+enum class Unit : uint32_t {
+ NONE = 0u,
+ OTHER = 1u,
+ DISTANCE = 2u,
+ WEIGHT = 3u,
+ ROTATION = 4u,
+ ANGULAR_VELOCITY = 5u,
+ LINEAR_VELOCITY = 6u,
+ ACCELERATION = 7u,
+ MAGNETIC_FLUX = 8u,
+ LUMINOUS_FLUX = 9u,
+ PRESSURE = 10u,
+ LUX = 11u,
+};
+
+
+enum class TouchType : uint32_t {
+ TOUCHSCREEN = 1u,
+};
+
+
+enum class SensorType : uint32_t {
+ ACCELEROMETER_X = 1u,
+ ACCELEROMETER_Y = 2u,
+ ACCELEROMETER_Z = 3u,
+ MAGNETOMETER_X = 4u,
+ MAGNETOMETER_Y = 5u,
+ MAGNETOMETER_Z = 6u,
+ GYROSCOPE_X = 7u,
+ GYROSCOPE_Y = 8u,
+ GYROSCOPE_Z = 9u,
+ LIGHT_ILLUMINANCE = 10u,
+ LIGHT_RED = 11u,
+ LIGHT_GREEN = 12u,
+ LIGHT_BLUE = 13u,
+};
+
+
+struct SensorReport;
+struct Range;
+struct Axis;
+struct SensorAxis;
+struct SensorDescriptor;
+struct MouseDescriptor;
+struct ContactDescriptor;
+struct TouchDescriptor;
+struct MouseReport;
+struct DeviceInfo;
+struct DeviceDescriptor;
+struct ContactReport;
+struct TouchReport;
+struct InputReport;
+class InputDevice;
+
+extern "C" const fidl_type_t fuchsia_input_report_SensorReportTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_SensorReportTable;
+
+// |SensorReport| gives the values measured by a sensor at a given point in time.
+struct SensorReport final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The ordering of |values| will always directly correspond to the ordering of
+ // the values in |SensorDescriptor|.
+ const ::fidl::VectorView<int64_t>& values() const {
+ ZX_ASSERT(has_values());
+ return *reinterpret_cast<const ::fidl::VectorView<int64_t>*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::fidl::VectorView<int64_t>& values() {
+ ZX_ASSERT(has_values());
+ return *reinterpret_cast<::fidl::VectorView<int64_t>*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_values() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ SensorReport() = default;
+ ~SensorReport() = default;
+ SensorReport(SensorReport&& other) noexcept = default;
+ SensorReport& operator=(SensorReport&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_SensorReportTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_SensorReportTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 832;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 832;
+
+ private:
+ SensorReport(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class SensorReport::Builder {
+ public:
+ SensorReport view() { return SensorReport(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The ordering of |values| will always directly correspond to the ordering of
+ // the values in |SensorDescriptor|.
+ Builder&& set_values(::fidl::VectorView<int64_t>* elem);
+
+ private:
+ Builder() = default;
+ friend Builder SensorReport::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_SensorDescriptorTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_SensorDescriptorTable;
+
+// |SensorDescriptor| describes the capabilities of a sensor.
+struct SensorDescriptor final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Each |SensorAxis| in |values| describes what a sensor is measuring and its range.
+ // These will directly correspond to the values in |SensorReport|.
+ const ::fidl::VectorView<::llcpp::fuchsia::input::report::SensorAxis>& values() const {
+ ZX_ASSERT(has_values());
+ return *reinterpret_cast<const ::fidl::VectorView<::llcpp::fuchsia::input::report::SensorAxis>*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::fidl::VectorView<::llcpp::fuchsia::input::report::SensorAxis>& values() {
+ ZX_ASSERT(has_values());
+ return *reinterpret_cast<::fidl::VectorView<::llcpp::fuchsia::input::report::SensorAxis>*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_values() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ SensorDescriptor() = default;
+ ~SensorDescriptor() = default;
+ SensorDescriptor(SensorDescriptor&& other) noexcept = default;
+ SensorDescriptor& operator=(SensorDescriptor&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_SensorDescriptorTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_SensorDescriptorTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 3232;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 3232;
+
+ private:
+ SensorDescriptor(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class SensorDescriptor::Builder {
+ public:
+ SensorDescriptor view() { return SensorDescriptor(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Each |SensorAxis| in |values| describes what a sensor is measuring and its range.
+ // These will directly correspond to the values in |SensorReport|.
+ Builder&& set_values(::fidl::VectorView<::llcpp::fuchsia::input::report::SensorAxis>* elem);
+
+ private:
+ Builder() = default;
+ friend Builder SensorDescriptor::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_MouseDescriptorTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_MouseDescriptorTable;
+
+// |MouseDescriptor| describes the capabilities of a mouse.
+struct MouseDescriptor final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The range of relative X movement.
+ const ::llcpp::fuchsia::input::report::Axis& movement_x() const {
+ ZX_ASSERT(has_movement_x());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& movement_x() {
+ ZX_ASSERT(has_movement_x());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_movement_x() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // The range of relative Y movement.
+ const ::llcpp::fuchsia::input::report::Axis& movement_y() const {
+ ZX_ASSERT(has_movement_y());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& movement_y() {
+ ZX_ASSERT(has_movement_y());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_movement_y() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // The range of relative vertical scroll.
+ const ::llcpp::fuchsia::input::report::Axis& scroll_v() const {
+ ZX_ASSERT(has_scroll_v());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& scroll_v() {
+ ZX_ASSERT(has_scroll_v());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_scroll_v() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // The range of relative horizontal scroll.
+ const ::llcpp::fuchsia::input::report::Axis& scroll_h() const {
+ ZX_ASSERT(has_scroll_h());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(4 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& scroll_h() {
+ ZX_ASSERT(has_scroll_h());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_scroll_h() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ // This is a vector of id's for the mouse buttons.
+ const ::fidl::VectorView<uint8_t>& buttons() const {
+ ZX_ASSERT(has_buttons());
+ return *reinterpret_cast<const ::fidl::VectorView<uint8_t>*>(EnvelopesView::at(5 - 1).data);
+ }
+ ::fidl::VectorView<uint8_t>& buttons() {
+ ZX_ASSERT(has_buttons());
+ return *reinterpret_cast<::fidl::VectorView<uint8_t>*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_buttons() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ MouseDescriptor() = default;
+ ~MouseDescriptor() = default;
+ MouseDescriptor(MouseDescriptor&& other) noexcept = default;
+ MouseDescriptor& operator=(MouseDescriptor&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_MouseDescriptorTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_MouseDescriptorTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 224;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 224;
+
+ private:
+ MouseDescriptor(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class MouseDescriptor::Builder {
+ public:
+ MouseDescriptor view() { return MouseDescriptor(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The range of relative X movement.
+ Builder&& set_movement_x(::llcpp::fuchsia::input::report::Axis* elem);
+
+ // The range of relative Y movement.
+ Builder&& set_movement_y(::llcpp::fuchsia::input::report::Axis* elem);
+
+ // The range of relative vertical scroll.
+ Builder&& set_scroll_v(::llcpp::fuchsia::input::report::Axis* elem);
+
+ // The range of relative horizontal scroll.
+ Builder&& set_scroll_h(::llcpp::fuchsia::input::report::Axis* elem);
+
+ // This is a vector of id's for the mouse buttons.
+ Builder&& set_buttons(::fidl::VectorView<uint8_t>* elem);
+
+ private:
+ Builder() = default;
+ friend Builder MouseDescriptor::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 5> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_ContactDescriptorTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_ContactDescriptorTable;
+
+// `ContactDescriptor` describes the fields associated with a touch on a touch device.
+struct ContactDescriptor final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Describes the reporting of the x-axis.
+ const ::llcpp::fuchsia::input::report::Axis& position_x() const {
+ ZX_ASSERT(has_position_x());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& position_x() {
+ ZX_ASSERT(has_position_x());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_position_x() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Describes the reporting of the y-axis.
+ const ::llcpp::fuchsia::input::report::Axis& position_y() const {
+ ZX_ASSERT(has_position_y());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& position_y() {
+ ZX_ASSERT(has_position_y());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_position_y() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // Pressure of the contact.
+ const ::llcpp::fuchsia::input::report::Axis& pressure() const {
+ ZX_ASSERT(has_pressure());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& pressure() {
+ ZX_ASSERT(has_pressure());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_pressure() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // Width of the area of contact.
+ const ::llcpp::fuchsia::input::report::Axis& contact_width() const {
+ ZX_ASSERT(has_contact_width());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(4 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& contact_width() {
+ ZX_ASSERT(has_contact_width());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_contact_width() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ // Height of the area of contact.
+ const ::llcpp::fuchsia::input::report::Axis& contact_height() const {
+ ZX_ASSERT(has_contact_height());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(5 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::Axis& contact_height() {
+ ZX_ASSERT(has_contact_height());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::Axis*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_contact_height() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ ContactDescriptor() = default;
+ ~ContactDescriptor() = default;
+ ContactDescriptor(ContactDescriptor&& other) noexcept = default;
+ ContactDescriptor& operator=(ContactDescriptor&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_ContactDescriptorTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_ContactDescriptorTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 200;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 200;
+
+ private:
+ ContactDescriptor(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class ContactDescriptor::Builder {
+ public:
+ ContactDescriptor view() { return ContactDescriptor(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Describes the reporting of the x-axis.
+ Builder&& set_position_x(::llcpp::fuchsia::input::report::Axis* elem);
+
+ // Describes the reporting of the y-axis.
+ Builder&& set_position_y(::llcpp::fuchsia::input::report::Axis* elem);
+
+ // Pressure of the contact.
+ Builder&& set_pressure(::llcpp::fuchsia::input::report::Axis* elem);
+
+ // Width of the area of contact.
+ Builder&& set_contact_width(::llcpp::fuchsia::input::report::Axis* elem);
+
+ // Height of the area of contact.
+ Builder&& set_contact_height(::llcpp::fuchsia::input::report::Axis* elem);
+
+ private:
+ Builder() = default;
+ friend Builder ContactDescriptor::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 5> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_TouchDescriptorTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_TouchDescriptorTable;
+
+// `TouchDescriptor` describes the fields associated with an individual touch device.
+struct TouchDescriptor final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The contact descriptors associated with this touch descriptor.
+ const ::fidl::VectorView<::llcpp::fuchsia::input::report::ContactDescriptor>& contacts() const {
+ ZX_ASSERT(has_contacts());
+ return *reinterpret_cast<const ::fidl::VectorView<::llcpp::fuchsia::input::report::ContactDescriptor>*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::fidl::VectorView<::llcpp::fuchsia::input::report::ContactDescriptor>& contacts() {
+ ZX_ASSERT(has_contacts());
+ return *reinterpret_cast<::fidl::VectorView<::llcpp::fuchsia::input::report::ContactDescriptor>*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_contacts() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // The max number of contacts that this touch device can report at once.
+ const uint32_t& max_contacts() const {
+ ZX_ASSERT(has_max_contacts());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ uint32_t& max_contacts() {
+ ZX_ASSERT(has_max_contacts());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_max_contacts() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // The type of touch device being used.
+ const ::llcpp::fuchsia::input::report::TouchType& touch_type() const {
+ ZX_ASSERT(has_touch_type());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::TouchType*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::TouchType& touch_type() {
+ ZX_ASSERT(has_touch_type());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::TouchType*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_touch_type() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ TouchDescriptor() = default;
+ ~TouchDescriptor() = default;
+ TouchDescriptor(TouchDescriptor&& other) noexcept = default;
+ TouchDescriptor& operator=(TouchDescriptor&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_TouchDescriptorTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_TouchDescriptorTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 2240;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 2240;
+
+ private:
+ TouchDescriptor(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class TouchDescriptor::Builder {
+ public:
+ TouchDescriptor view() { return TouchDescriptor(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The contact descriptors associated with this touch descriptor.
+ Builder&& set_contacts(::fidl::VectorView<::llcpp::fuchsia::input::report::ContactDescriptor>* elem);
+
+ // The max number of contacts that this touch device can report at once.
+ Builder&& set_max_contacts(uint32_t* elem);
+
+ // The type of touch device being used.
+ Builder&& set_touch_type(::llcpp::fuchsia::input::report::TouchType* elem);
+
+ private:
+ Builder() = default;
+ friend Builder TouchDescriptor::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 3> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_MouseReportTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_MouseReportTable;
+
+// |MouseReport| gives the relative movement of the mouse and currently
+// pressed buttons. Relative means the movement seen between the previous
+// report and this report. The client is responsble for tracking this and
+// converting it to absolute movement.
+struct MouseReport final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Relative X positional displacement.
+ const int64_t& movement_x() const {
+ ZX_ASSERT(has_movement_x());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ int64_t& movement_x() {
+ ZX_ASSERT(has_movement_x());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_movement_x() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Relative Y positional displacement.
+ const int64_t& movement_y() const {
+ ZX_ASSERT(has_movement_y());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ int64_t& movement_y() {
+ ZX_ASSERT(has_movement_y());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_movement_y() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // Relative vertical scrolling displacement.
+ const int64_t& scroll_v() const {
+ ZX_ASSERT(has_scroll_v());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ int64_t& scroll_v() {
+ ZX_ASSERT(has_scroll_v());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_scroll_v() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // Relative horizontal scrolling displacement.
+ const int64_t& scroll_h() const {
+ ZX_ASSERT(has_scroll_h());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ int64_t& scroll_h() {
+ ZX_ASSERT(has_scroll_h());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_scroll_h() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ // A list of currently pressed buttons.
+ const ::fidl::VectorView<uint8_t>& pressed_buttons() const {
+ ZX_ASSERT(has_pressed_buttons());
+ return *reinterpret_cast<const ::fidl::VectorView<uint8_t>*>(EnvelopesView::at(5 - 1).data);
+ }
+ ::fidl::VectorView<uint8_t>& pressed_buttons() {
+ ZX_ASSERT(has_pressed_buttons());
+ return *reinterpret_cast<::fidl::VectorView<uint8_t>*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_pressed_buttons() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ MouseReport() = default;
+ ~MouseReport() = default;
+ MouseReport(MouseReport&& other) noexcept = default;
+ MouseReport& operator=(MouseReport&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_MouseReportTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_MouseReportTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 160;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 160;
+
+ private:
+ MouseReport(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class MouseReport::Builder {
+ public:
+ MouseReport view() { return MouseReport(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Relative X positional displacement.
+ Builder&& set_movement_x(int64_t* elem);
+
+ // Relative Y positional displacement.
+ Builder&& set_movement_y(int64_t* elem);
+
+ // Relative vertical scrolling displacement.
+ Builder&& set_scroll_v(int64_t* elem);
+
+ // Relative horizontal scrolling displacement.
+ Builder&& set_scroll_h(int64_t* elem);
+
+ // A list of currently pressed buttons.
+ Builder&& set_pressed_buttons(::fidl::VectorView<uint8_t>* elem);
+
+ private:
+ Builder() = default;
+ friend Builder MouseReport::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 5> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_DeviceDescriptorTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_DeviceDescriptorTable;
+
+// |DeviceDescriptor| describes a physical input device. Some physical devices may
+// send multiple types of reports (E.g: a physical touchscreen can send touch and
+// stylus reports, so it will have both a TouchDescriptor and a StylusDescriptor).
+struct DeviceDescriptor final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // |device_info| should always be present to help distinguish between physical devices.
+ const ::llcpp::fuchsia::input::report::DeviceInfo& device_info() const {
+ ZX_ASSERT(has_device_info());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::DeviceInfo*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::DeviceInfo& device_info() {
+ ZX_ASSERT(has_device_info());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::DeviceInfo*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_device_info() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // When |mouse| is present the device has a mouse.
+ const ::llcpp::fuchsia::input::report::MouseDescriptor& mouse() const {
+ ZX_ASSERT(has_mouse());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::MouseDescriptor*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::MouseDescriptor& mouse() {
+ ZX_ASSERT(has_mouse());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::MouseDescriptor*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_mouse() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // When |sensor| is present the device has a sensor.
+ const ::llcpp::fuchsia::input::report::SensorDescriptor& sensor() const {
+ ZX_ASSERT(has_sensor());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::SensorDescriptor*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::SensorDescriptor& sensor() {
+ ZX_ASSERT(has_sensor());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::SensorDescriptor*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_sensor() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // When |touch| is present the device has a touch device.
+ // (E.g: Touchscreen, touchpad).
+ const ::llcpp::fuchsia::input::report::TouchDescriptor& touch() const {
+ ZX_ASSERT(has_touch());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::TouchDescriptor*>(EnvelopesView::at(4 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::TouchDescriptor& touch() {
+ ZX_ASSERT(has_touch());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::TouchDescriptor*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_touch() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ DeviceDescriptor() = default;
+ ~DeviceDescriptor() = default;
+ DeviceDescriptor(DeviceDescriptor&& other) noexcept = default;
+ DeviceDescriptor& operator=(DeviceDescriptor&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_DeviceDescriptorTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_DeviceDescriptorTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 6096;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 6096;
+
+ private:
+ DeviceDescriptor(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class DeviceDescriptor::Builder {
+ public:
+ DeviceDescriptor view() { return DeviceDescriptor(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // |device_info| should always be present to help distinguish between physical devices.
+ Builder&& set_device_info(::llcpp::fuchsia::input::report::DeviceInfo* elem);
+
+ // When |mouse| is present the device has a mouse.
+ Builder&& set_mouse(::llcpp::fuchsia::input::report::MouseDescriptor* elem);
+
+ // When |sensor| is present the device has a sensor.
+ Builder&& set_sensor(::llcpp::fuchsia::input::report::SensorDescriptor* elem);
+
+ // When |touch| is present the device has a touch device.
+ // (E.g: Touchscreen, touchpad).
+ Builder&& set_touch(::llcpp::fuchsia::input::report::TouchDescriptor* elem);
+
+ private:
+ Builder() = default;
+ friend Builder DeviceDescriptor::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 4> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_ContactReportTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_ContactReportTable;
+
+// `Contact` describes one touch on a touch device.
+struct ContactReport final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Identifier for this contact.
+ const uint32_t& contact_id() const {
+ ZX_ASSERT(has_contact_id());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ uint32_t& contact_id() {
+ ZX_ASSERT(has_contact_id());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_contact_id() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // A contact's position on the x axis.
+ const int64_t& position_x() const {
+ ZX_ASSERT(has_position_x());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ int64_t& position_x() {
+ ZX_ASSERT(has_position_x());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_position_x() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // A contact's position on the y axis.
+ const int64_t& position_y() const {
+ ZX_ASSERT(has_position_y());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ int64_t& position_y() {
+ ZX_ASSERT(has_position_y());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_position_y() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // Pressure of the contact.
+ const int64_t& pressure() const {
+ ZX_ASSERT(has_pressure());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ int64_t& pressure() {
+ ZX_ASSERT(has_pressure());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_pressure() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ // Width of the bounding box around the touch contact. Combined with
+ // `contact_height`, this describes the area of the touch contact.
+ // `contact_width` and `contact_height` should both have units of distance,
+ // and they should be in the same units as `position_x` and `position_y`.
+ const int64_t& contact_width() const {
+ ZX_ASSERT(has_contact_width());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ int64_t& contact_width() {
+ ZX_ASSERT(has_contact_width());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_contact_width() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ // Height of the bounding box around the touch contact. Combined with
+ // `contact_width`, this describes the area of the touch contact.
+ // `contact_width` and `contact_height` should both have units of distance,
+ // and they should be in the same units as `position_x` and `position_y`.
+ const int64_t& contact_height() const {
+ ZX_ASSERT(has_contact_height());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(6 - 1).data);
+ }
+ int64_t& contact_height() {
+ ZX_ASSERT(has_contact_height());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(6 - 1).data);
+ }
+ bool has_contact_height() const {
+ return EnvelopesView::count() >= 6 && EnvelopesView::at(6 - 1).data != nullptr;
+ }
+
+ ContactReport() = default;
+ ~ContactReport() = default;
+ ContactReport(ContactReport&& other) noexcept = default;
+ ContactReport& operator=(ContactReport&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_ContactReportTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_ContactReportTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 144;
+
+ private:
+ ContactReport(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class ContactReport::Builder {
+ public:
+ ContactReport view() { return ContactReport(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Identifier for this contact.
+ Builder&& set_contact_id(uint32_t* elem);
+
+ // A contact's position on the x axis.
+ Builder&& set_position_x(int64_t* elem);
+
+ // A contact's position on the y axis.
+ Builder&& set_position_y(int64_t* elem);
+
+ // Pressure of the contact.
+ Builder&& set_pressure(int64_t* elem);
+
+ // Width of the bounding box around the touch contact. Combined with
+ // `contact_height`, this describes the area of the touch contact.
+ // `contact_width` and `contact_height` should both have units of distance,
+ // and they should be in the same units as `position_x` and `position_y`.
+ Builder&& set_contact_width(int64_t* elem);
+
+ // Height of the bounding box around the touch contact. Combined with
+ // `contact_width`, this describes the area of the touch contact.
+ // `contact_width` and `contact_height` should both have units of distance,
+ // and they should be in the same units as `position_x` and `position_y`.
+ Builder&& set_contact_height(int64_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder ContactReport::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 6> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_TouchReportTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_TouchReportTable;
+
+// `TouchscreenReport` describes the current contacts recorded by the touchscreen.
+struct TouchReport final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The contacts currently being reported by the device.
+ const ::fidl::VectorView<::llcpp::fuchsia::input::report::ContactReport>& contacts() const {
+ ZX_ASSERT(has_contacts());
+ return *reinterpret_cast<const ::fidl::VectorView<::llcpp::fuchsia::input::report::ContactReport>*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::fidl::VectorView<::llcpp::fuchsia::input::report::ContactReport>& contacts() {
+ ZX_ASSERT(has_contacts());
+ return *reinterpret_cast<::fidl::VectorView<::llcpp::fuchsia::input::report::ContactReport>*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_contacts() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ TouchReport() = default;
+ ~TouchReport() = default;
+ TouchReport(TouchReport&& other) noexcept = default;
+ TouchReport& operator=(TouchReport&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_TouchReportTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_TouchReportTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 1632;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 1632;
+
+ private:
+ TouchReport(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class TouchReport::Builder {
+ public:
+ TouchReport view() { return TouchReport(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The contacts currently being reported by the device.
+ Builder&& set_contacts(::fidl::VectorView<::llcpp::fuchsia::input::report::ContactReport>* elem);
+
+ private:
+ Builder() = default;
+ friend Builder TouchReport::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_InputReportTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputReportTable;
+
+// |InputReport| is a single report that is created by an input device.
+struct InputReport final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // |event_time| is in nanoseconds when the event was recorded.
+ const int64_t& event_time() const {
+ ZX_ASSERT(has_event_time());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ int64_t& event_time() {
+ ZX_ASSERT(has_event_time());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_event_time() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // |mouse| is the report generated if the device contains a mouse.
+ const ::llcpp::fuchsia::input::report::MouseReport& mouse() const {
+ ZX_ASSERT(has_mouse());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::MouseReport*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::MouseReport& mouse() {
+ ZX_ASSERT(has_mouse());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::MouseReport*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_mouse() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // Unique ID to connect trace async begin/end events.
+ const uint64_t& trace_id() const {
+ ZX_ASSERT(has_trace_id());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ uint64_t& trace_id() {
+ ZX_ASSERT(has_trace_id());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_trace_id() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // |sensor| is the report generated if the device contains a sensor.
+ const ::llcpp::fuchsia::input::report::SensorReport& sensor() const {
+ ZX_ASSERT(has_sensor());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::SensorReport*>(EnvelopesView::at(4 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::SensorReport& sensor() {
+ ZX_ASSERT(has_sensor());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::SensorReport*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_sensor() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ // |touch| is the report generated if the device contains a touch device.
+ const ::llcpp::fuchsia::input::report::TouchReport& touch() const {
+ ZX_ASSERT(has_touch());
+ return *reinterpret_cast<const ::llcpp::fuchsia::input::report::TouchReport*>(EnvelopesView::at(5 - 1).data);
+ }
+ ::llcpp::fuchsia::input::report::TouchReport& touch() {
+ ZX_ASSERT(has_touch());
+ return *reinterpret_cast<::llcpp::fuchsia::input::report::TouchReport*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_touch() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ InputReport() = default;
+ ~InputReport() = default;
+ InputReport(InputReport&& other) noexcept = default;
+ InputReport& operator=(InputReport&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_InputReportTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_InputReportTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 2768;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 2768;
+
+ private:
+ InputReport(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class InputReport::Builder {
+ public:
+ InputReport view() { return InputReport(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // |event_time| is in nanoseconds when the event was recorded.
+ Builder&& set_event_time(int64_t* elem);
+
+ // |mouse| is the report generated if the device contains a mouse.
+ Builder&& set_mouse(::llcpp::fuchsia::input::report::MouseReport* elem);
+
+ // Unique ID to connect trace async begin/end events.
+ Builder&& set_trace_id(uint64_t* elem);
+
+ // |sensor| is the report generated if the device contains a sensor.
+ Builder&& set_sensor(::llcpp::fuchsia::input::report::SensorReport* elem);
+
+ // |touch| is the report generated if the device contains a touch device.
+ Builder&& set_touch(::llcpp::fuchsia::input::report::TouchReport* elem);
+
+ private:
+ Builder() = default;
+ friend Builder InputReport::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 5> envelopes_ = {};
+};
+
+// A hardcoded number of max contacts per report. This should be increased in the future if
+// we see devices with more than the max amount.
+constexpr uint32_t TOUCH_MAX_CONTACTS = 10u;
+
+// A hardcoded number of max sensor values. This should be increased in the future
+// if we ever see a sensor with more values.
+constexpr uint32_t SENSOR_MAX_VALUES = 100u;
+
+extern "C" const fidl_type_t fuchsia_input_report_RangeTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_RangeTable;
+
+// Describe a |Range| of values.
+struct Range {
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_RangeTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_RangeTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 0;
+
+ int64_t min = {};
+
+ int64_t max = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_AxisTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_AxisTable;
+
+// An |Axis| is defined as a |range| and a |unit|.
+struct Axis {
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_AxisTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_AxisTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 0;
+
+ ::llcpp::fuchsia::input::report::Range range = {};
+
+ ::llcpp::fuchsia::input::report::Unit unit = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_SensorAxisTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_SensorAxisTable;
+
+// A |SensorAxis| is a normal |Axis| with an additional |SensorType| to describe what the
+// axis is measuring.
+struct SensorAxis {
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_SensorAxisTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_SensorAxisTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 0;
+
+ ::llcpp::fuchsia::input::report::Axis axis = {};
+
+ ::llcpp::fuchsia::input::report::SensorType type = {};
+};
+
+// A hardcoded number of max mouse buttons. This should be increased in the future
+// if we ever see mice with more buttons.
+constexpr uint32_t MOUSE_MAX_NUM_BUTTONS = 32u;
+
+constexpr uint32_t MAX_DEVICE_REPORT_COUNT = 50u;
+
+constexpr uint32_t MAX_DEVICE_NAME_LENGTH = 256u;
+
+extern "C" const fidl_type_t fuchsia_input_report_DeviceInfoTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_DeviceInfoTable;
+
+// DeviceInfo provides more information about the device and lets a client
+// distinguish between devices (e.g between two touchscreens that come from
+// different vendors). If the device is a HID device, then the id information
+// will come from the device itself. Other, non-HID devices may assign the
+// ids in the driver, so it will be the driver author's responsibility to
+// assign sensible ids.
+struct DeviceInfo {
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_DeviceInfoTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_DeviceInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 256;
+ static constexpr uint32_t AltPrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t AltMaxOutOfLine = 256;
+
+ uint32_t vendor_id = {};
+
+ uint32_t product_id = {};
+
+ uint32_t version = {};
+
+ ::fidl::StringView name = {};
+};
+
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetReportsEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetReportsEventRequestTable;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetReportsEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetReportsEventResponseTable;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetReportsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetReportsRequestTable;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetReportsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetReportsResponseTable;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetDescriptorRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetDescriptorRequestTable;
+extern "C" const fidl_type_t fuchsia_input_report_InputDeviceGetDescriptorResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_input_report_InputDeviceGetDescriptorResponseTable;
+
+// An |InputDevice| driver represents a single physical input device.
+// The InputDevice maintains an internal FIFO of |MAX_DEVICE_REPORT_COUNT|
+// reports for each client that connects. Reports are removed from the FIFO
+// once they are read by the client. If the FIFO is full, it will drop the
+// oldest report to make room for an incoming report.
+class InputDevice final {
+ InputDevice() = delete;
+ public:
+
+ struct GetReportsEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::event event;
+
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_InputDeviceGetReportsEventResponseTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_InputDeviceGetReportsEventResponseTable;
+ 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 ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetReportsEventRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetReportsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::input::report::InputReport> reports;
+
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_InputDeviceGetReportsResponseTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_InputDeviceGetReportsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 139200;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 139200;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetReportsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDescriptorResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::input::report::DeviceDescriptor descriptor;
+
+ static constexpr const fidl_type_t* Type = &fuchsia_input_report_InputDeviceGetDescriptorResponseTable;
+ static constexpr const fidl_type_t* AltType = &v1_fuchsia_input_report_InputDeviceGetDescriptorResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 6096;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 6096;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetDescriptorRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetReportsEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReportsEvent_Impl(zx::unowned_channel _client_end);
+ ~GetReportsEvent_Impl() = default;
+ GetReportsEvent_Impl(GetReportsEvent_Impl&& other) = default;
+ GetReportsEvent_Impl& operator=(GetReportsEvent_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 GetReports_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReports_Impl(zx::unowned_channel _client_end);
+ ~GetReports_Impl() = default;
+ GetReports_Impl(GetReports_Impl&& other) = default;
+ GetReports_Impl& operator=(GetReports_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 GetDescriptor_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDescriptor_Impl(zx::unowned_channel _client_end);
+ ~GetDescriptor_Impl() = default;
+ GetDescriptor_Impl(GetDescriptor_Impl&& other) = default;
+ GetDescriptor_Impl& operator=(GetDescriptor_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 GetReportsEvent = GetReportsEvent_Impl<GetReportsEventResponse>;
+ using GetReports = GetReports_Impl<GetReportsResponse>;
+ using GetDescriptor = GetDescriptor_Impl<GetDescriptorResponse>;
+ };
+
+ // 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 GetReportsEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReportsEvent_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetReportsEvent_Impl() = default;
+ GetReportsEvent_Impl(GetReportsEvent_Impl&& other) = default;
+ GetReportsEvent_Impl& operator=(GetReportsEvent_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 GetReports_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReports_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetReports_Impl() = default;
+ GetReports_Impl(GetReports_Impl&& other) = default;
+ GetReports_Impl& operator=(GetReports_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 GetDescriptor_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDescriptor_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDescriptor_Impl() = default;
+ GetDescriptor_Impl(GetDescriptor_Impl&& other) = default;
+ GetDescriptor_Impl& operator=(GetDescriptor_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 GetReportsEvent = GetReportsEvent_Impl<GetReportsEventResponse>;
+ using GetReports = GetReports_Impl<GetReportsResponse>;
+ using GetDescriptor = GetDescriptor_Impl<GetDescriptorResponse>;
+ };
+
+ 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_; }
+
+ // Receive an event that will be signalled when there are reports in the
+ // Device's report FIFO. When there are events in the FIFO, |event| will have
+ // |DEV_STATE_READABLE| triggered. When the client has read all of the events,
+ // |DEV_STATE_READABLE| will be cleared.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetReportsEvent GetReportsEvent();
+
+ // Receive an event that will be signalled when there are reports in the
+ // Device's report FIFO. When there are events in the FIFO, |event| will have
+ // |DEV_STATE_READABLE| triggered. When the client has read all of the events,
+ // |DEV_STATE_READABLE| will be cleared.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReportsEvent GetReportsEvent(::fidl::BytePart _response_buffer);
+
+ // Get all of the reports that have been seen since the last time this method was called.
+ // If this returns 0 reports, please wait on the report event.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetReports GetReports();
+
+ // Get all of the reports that have been seen since the last time this method was called.
+ // If this returns 0 reports, please wait on the report event.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReports GetReports(::fidl::BytePart _response_buffer);
+
+ // Gets the device descriptor for this device.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetDescriptor GetDescriptor();
+
+ // Gets the device descriptor for this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDescriptor GetDescriptor(::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:
+
+ // Receive an event that will be signalled when there are reports in the
+ // Device's report FIFO. When there are events in the FIFO, |event| will have
+ // |DEV_STATE_READABLE| triggered. When the client has read all of the events,
+ // |DEV_STATE_READABLE| will be cleared.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetReportsEvent GetReportsEvent(zx::unowned_channel _client_end);
+
+ // Receive an event that will be signalled when there are reports in the
+ // Device's report FIFO. When there are events in the FIFO, |event| will have
+ // |DEV_STATE_READABLE| triggered. When the client has read all of the events,
+ // |DEV_STATE_READABLE| will be cleared.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReportsEvent GetReportsEvent(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get all of the reports that have been seen since the last time this method was called.
+ // If this returns 0 reports, please wait on the report event.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetReports GetReports(zx::unowned_channel _client_end);
+
+ // Get all of the reports that have been seen since the last time this method was called.
+ // If this returns 0 reports, please wait on the report event.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReports GetReports(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Gets the device descriptor for this device.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetDescriptor GetDescriptor(zx::unowned_channel _client_end);
+
+ // Gets the device descriptor for this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDescriptor GetDescriptor(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:
+
+ // Receive an event that will be signalled when there are reports in the
+ // Device's report FIFO. When there are events in the FIFO, |event| will have
+ // |DEV_STATE_READABLE| triggered. When the client has read all of the events,
+ // |DEV_STATE_READABLE| will be cleared.
+ static ::fidl::DecodeResult<GetReportsEventResponse> GetReportsEvent(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get all of the reports that have been seen since the last time this method was called.
+ // If this returns 0 reports, please wait on the report event.
+ static ::fidl::DecodeResult<GetReportsResponse> GetReports(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Gets the device descriptor for this device.
+ static ::fidl::DecodeResult<GetDescriptorResponse> GetDescriptor(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 = InputDevice;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetReportsEventCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::event event);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event event);
+ void Reply(::fidl::DecodedMessage<GetReportsEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportsEventCompleter = ::fidl::Completer<GetReportsEventCompleterBase>;
+
+ virtual void GetReportsEvent(GetReportsEventCompleter::Sync _completer) = 0;
+
+ class GetReportsCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::input::report::InputReport> reports);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::input::report::InputReport> reports);
+ void Reply(::fidl::DecodedMessage<GetReportsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportsCompleter = ::fidl::Completer<GetReportsCompleterBase>;
+
+ virtual void GetReports(GetReportsCompleter::Sync _completer) = 0;
+
+ class GetDescriptorCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::input::report::DeviceDescriptor descriptor);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::input::report::DeviceDescriptor descriptor);
+ void Reply(::fidl::DecodedMessage<GetDescriptorResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDescriptorCompleter = ::fidl::Completer<GetDescriptorCompleterBase>;
+
+ virtual void GetDescriptor(GetDescriptorCompleter::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 GetReportsEventRequest(const ::fidl::DecodedMessage<InputDevice::GetReportsEventRequest>& _msg);
+ static void GetReportsEventResponse(const ::fidl::DecodedMessage<InputDevice::GetReportsEventResponse>& _msg);
+ static void GetReportsRequest(const ::fidl::DecodedMessage<InputDevice::GetReportsRequest>& _msg);
+ static void GetReportsResponse(const ::fidl::DecodedMessage<InputDevice::GetReportsResponse>& _msg);
+ static void GetDescriptorRequest(const ::fidl::DecodedMessage<InputDevice::GetDescriptorRequest>& _msg);
+ static void GetDescriptorResponse(const ::fidl::DecodedMessage<InputDevice::GetDescriptorResponse>& _msg);
+ };
+};
+
+} // namespace report
+} // namespace input
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::SensorReport> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::SensorReport>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::Range> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::Range>);
+static_assert(offsetof(::llcpp::fuchsia::input::report::Range, min) == 0);
+static_assert(offsetof(::llcpp::fuchsia::input::report::Range, max) == 8);
+static_assert(sizeof(::llcpp::fuchsia::input::report::Range) == ::llcpp::fuchsia::input::report::Range::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::Axis> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::Axis>);
+static_assert(offsetof(::llcpp::fuchsia::input::report::Axis, range) == 0);
+static_assert(offsetof(::llcpp::fuchsia::input::report::Axis, unit) == 16);
+static_assert(sizeof(::llcpp::fuchsia::input::report::Axis) == ::llcpp::fuchsia::input::report::Axis::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::SensorAxis> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::SensorAxis>);
+static_assert(offsetof(::llcpp::fuchsia::input::report::SensorAxis, axis) == 0);
+static_assert(offsetof(::llcpp::fuchsia::input::report::SensorAxis, type) == 24);
+static_assert(sizeof(::llcpp::fuchsia::input::report::SensorAxis) == ::llcpp::fuchsia::input::report::SensorAxis::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::SensorDescriptor> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::SensorDescriptor>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::MouseDescriptor> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::MouseDescriptor>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::ContactDescriptor> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::ContactDescriptor>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::TouchDescriptor> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::TouchDescriptor>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::MouseReport> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::MouseReport>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::DeviceInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::DeviceInfo>);
+static_assert(offsetof(::llcpp::fuchsia::input::report::DeviceInfo, vendor_id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::input::report::DeviceInfo, product_id) == 4);
+static_assert(offsetof(::llcpp::fuchsia::input::report::DeviceInfo, version) == 8);
+static_assert(offsetof(::llcpp::fuchsia::input::report::DeviceInfo, name) == 16);
+static_assert(sizeof(::llcpp::fuchsia::input::report::DeviceInfo) == ::llcpp::fuchsia::input::report::DeviceInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::DeviceDescriptor> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::DeviceDescriptor>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::ContactReport> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::ContactReport>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::TouchReport> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::TouchReport>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::InputReport> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::input::report::InputReport>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::InputDevice::GetReportsEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::input::report::InputDevice::GetReportsEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::input::report::InputDevice::GetReportsEventResponse)
+ == ::llcpp::fuchsia::input::report::InputDevice::GetReportsEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::input::report::InputDevice::GetReportsEventResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::input::report::InputDevice::GetReportsEventResponse, event) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::InputDevice::GetReportsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::input::report::InputDevice::GetReportsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::input::report::InputDevice::GetReportsResponse)
+ == ::llcpp::fuchsia::input::report::InputDevice::GetReportsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::input::report::InputDevice::GetReportsResponse, reports) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::input::report::InputDevice::GetDescriptorResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::input::report::InputDevice::GetDescriptorResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::input::report::InputDevice::GetDescriptorResponse)
+ == ::llcpp::fuchsia::input::report::InputDevice::GetDescriptorResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::input::report::InputDevice::GetDescriptorResponse, descriptor) == 16);
+
+} // namespace fidl
diff --git a/src/camera/drivers/test_utils/fake-buffer-collection.cc b/src/camera/drivers/test_utils/fake-buffer-collection.cc
index 0f25e2c..523c440 100644
--- a/src/camera/drivers/test_utils/fake-buffer-collection.cc
+++ b/src/camera/drivers/test_utils/fake-buffer-collection.cc
@@ -17,6 +17,7 @@
#include <src/camera/drivers/isp/modules/dma-format.h>
#include "fbl/algorithm.h"
+#include "zircon/system/fidl/fuchsia-sysmem/gen/llcpp/include/fuchsia/sysmem/llcpp/fidl.h"
namespace camera {
diff --git a/tools/fidlgen_llcpp_zircon/BUILD.gn b/tools/fidlgen_llcpp_zircon/BUILD.gn
new file mode 100644
index 0000000..37c7597
--- /dev/null
+++ b/tools/fidlgen_llcpp_zircon/BUILD.gn
@@ -0,0 +1,44 @@
+# Copyright 2018 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/compiled_action.gni")
+import("//build/config/fuchsia/zircon.gni")
+import("//build/host.gni")
+
+executable("fidlgen_llcpp_zircon") {
+ sources = [
+ "llcpp_codegen.cc",
+ "llcpp_codegen.h",
+ "main.cc",
+ ]
+ deps = [ "//third_party/rapidjson" ]
+}
+
+foreach(command,
+ [
+ "validate",
+ "update",
+ ]) {
+ compiled_action(command) {
+ tool = ":fidlgen_llcpp_zircon"
+ args = [
+ command,
+ rebase_path(zircon_root_build_dir, root_build_dir),
+ rebase_path("$root_build_dir/host_x64/fidlgen_llcpp", root_build_dir),
+ rebase_path("$target_gen_dir/fidlgen_llcpp_zircon_${command}.stamp",
+ root_build_dir),
+ rebase_path("$target_gen_dir/fidlgen_llcpp_zircon_${command}.d",
+ root_build_dir),
+ rebase_path("$target_gen_dir/validator_tmp", root_build_dir),
+ ]
+
+ # This dependency delivers $root_build_dir/tools/fidlgen_llcpp.
+ # It doesn't have to appear in inputs, because the tool will output
+ # the exact path to fidlgen_llcpp in the depfile.
+ deps = [ "//garnet/go/src/fidl" ]
+ depfile = "$target_gen_dir/fidlgen_llcpp_zircon_${command}.d"
+ inputs = [ "$zircon_root_build_dir/fidl_gen.json" ]
+ outputs = [ "$target_gen_dir/fidlgen_llcpp_zircon_${command}.stamp" ]
+ }
+}
diff --git a/tools/fidlgen_llcpp_zircon/OWNERS b/tools/fidlgen_llcpp_zircon/OWNERS
new file mode 100644
index 0000000..9d202aa
--- /dev/null
+++ b/tools/fidlgen_llcpp_zircon/OWNERS
@@ -0,0 +1 @@
+yifeit@google.com
\ No newline at end of file
diff --git a/tools/fidlgen_llcpp_zircon/README.md b/tools/fidlgen_llcpp_zircon/README.md
new file mode 100644
index 0000000..8baba8b
--- /dev/null
+++ b/tools/fidlgen_llcpp_zircon/README.md
@@ -0,0 +1,40 @@
+## Generated FIDL Low-Level C++ Bindings
+
+Because of BLD-427 and BLD-353 blocking invoking `fidlgen` from the zircon
+build, we intend to check in copies of llcpp bindings for select FIDL libraries,
+as a workaround, to support limited use of llcpp.
+
+Each checked in library can be referenced similar to the C bindings, e.g.
+whereas one would write `"$zx/system/fidl/fuchsia-mem:c"` to get the
+auto-generated C FIDL bindings, the llcpp version is
+`"$zx/system/fidl/fuchsia-mem:llcpp"`.
+
+When using it in source code, whereas one would write
+`#include <fuchsia/mem/c/fidl.h>` to import the C bindings header,
+the corresponding llcpp directive would be
+`#include <fuchsia/mem/llcpp/fidl.h>`.
+
+To regenerate all the bindings, simply run the following command:
+
+```bash
+fx build -k 0 tools/fidlgen_llcpp_zircon:update
+```
+
+The `-k 0` switches would keep the build going even if parts of zircon failed to
+build. The actual generation happens in the Fuchsia build phase, so you may use
+`Ctrl-C` to cancel the zircon phase while it is running, to move on to code
+generation more quickly.
+
+Note: GN makes heavy use of incremental builds based on file modification
+times. If you switched branches and noticed that some generated bindings are
+not updated properly (ninja printing `No work to do`), make sure the FIDL
+definitions are newer than the checked in bindings, by modifying them or
+running `touch`.
+
+As an extra precaution measure, the full build will validate that the generated
+bindings are up to date. You can manually run the same check with the following
+command:
+
+```bash
+fx build tools/fidlgen_llcpp_zircon:validate
+```
diff --git a/tools/fidlgen_llcpp_zircon/llcpp_codegen.cc b/tools/fidlgen_llcpp_zircon/llcpp_codegen.cc
new file mode 100644
index 0000000..ecae732
--- /dev/null
+++ b/tools/fidlgen_llcpp_zircon/llcpp_codegen.cc
@@ -0,0 +1,230 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <cstdio>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <unistd.h>
+#include <sys/wait.h>
+
+#include "llcpp_codegen.h"
+#include "rapidjson/document.h"
+#include "rapidjson/error/en.h"
+#include "rapidjson/istreamwrapper.h"
+
+namespace fs = std::filesystem;
+
+namespace {
+
+[[noreturn]] void FatalError(const std::string& info) {
+ std::cerr << "Error: " << info << ", errno: " << strerror(errno) << std::endl;
+ exit(1);
+}
+
+rapidjson::Document ReadMetadata(const fs::path& path) {
+ rapidjson::Document metadata;
+ std::ifstream contents(path);
+ if (contents.fail()) {
+ FatalError("Failed to read GN metadata at " + std::string(path));
+ }
+ rapidjson::IStreamWrapper isw(contents);
+ rapidjson::ParseResult parse_result = metadata.ParseStream(isw);
+ if (!parse_result) {
+ FatalError("Failed to parse " + std::string(path) + ", " +
+ rapidjson::GetParseError_En(parse_result.Code()) + ", offset " +
+ std::to_string(parse_result.Offset()));
+ }
+ if (!metadata.IsArray()) {
+ FatalError("Metadata is not an array");
+ }
+ return metadata;
+}
+
+struct Target {
+ fs::path gen_dir;
+ std::string name;
+ std::vector<fs::path> fidl_sources;
+ std::vector<std::string> args;
+ fs::path json;
+ fs::path header;
+ fs::path source;
+ fs::path include_base;
+};
+
+std::vector<Target> AllTargets(const fs::path& zircon_build_root) {
+ std::vector<Target> targets_vector;
+ const auto metadata = ReadMetadata(zircon_build_root / "fidl_gen.json");
+ for (auto value_it = metadata.Begin();
+ value_it != metadata.End(); ++value_it) {
+ const auto& target = *value_it;
+ const rapidjson::Value& args = target["args"];
+ if (!args.IsArray()) {
+ FatalError("args in metadata JSON must be an array");
+ }
+ std::vector<std::string> args_vector;
+ for (auto arg_it = args.Begin(); arg_it != args.End(); ++arg_it) {
+ args_vector.emplace_back(arg_it->GetString());
+ }
+ const rapidjson::Value& fidl_sources = target["fidl_sources"];
+ if (!fidl_sources.IsArray()) {
+ FatalError("fidl_sources in metadata JSON must be an array");
+ }
+ std::vector<fs::path> fidl_sources_vector;
+ for (auto it = fidl_sources.Begin(); it != fidl_sources.End(); ++it) {
+ fidl_sources_vector.emplace_back(fs::path(it->GetString()));
+ }
+ targets_vector.push_back(Target {
+ .gen_dir = fs::path(target["target_gen_dir"].GetString()),
+ .name = target["name"].GetString(),
+ .fidl_sources = std::move(fidl_sources_vector),
+ .args = std::move(args_vector),
+ .json = fs::path(target["json"].GetString()),
+ .header = fs::path(target["header"].GetString()),
+ .source = fs::path(target["source"].GetString()),
+ .include_base = fs::path(target["include_base"].GetString()),
+ });
+ }
+ return targets_vector;
+}
+
+// Run a command with the specified command, working directory, and arguments.
+void RunCommand(const std::string& cmd, const std::string& working_directory,
+ std::vector<std::string> args) {
+ pid_t pid = fork();
+ int status;
+ switch (pid) {
+ case -1:
+ FatalError("Failed to fork");
+ case 0: {
+ status = chdir(working_directory.c_str());
+ if (status != 0) {
+ FatalError("Failed to chdir to " + working_directory);
+ }
+ std::vector<char *> c_args;
+ c_args.push_back(const_cast<char *>(cmd.c_str()));
+ for (const auto& arg : args) {
+ c_args.push_back(const_cast<char *>(arg.c_str()));
+ }
+ c_args.push_back(nullptr);
+ execv(cmd.c_str(), &c_args[0]);
+ FatalError("when executing " + cmd + ", execv should not return");
+ }
+ default:
+ pid_t ret_pid = waitpid(pid, &status, 0);
+ if (pid != ret_pid) {
+ FatalError("when executing " + cmd +
+ ", unexpected return value from waitpid: " +
+ std::to_string(ret_pid));
+ }
+ if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
+ FatalError(cmd + " returned an error: " + std::to_string(status));
+ }
+ }
+}
+
+fs::path FindCommonPath(fs::path a, fs::path b) {
+ auto a_it = a.begin();
+ auto b_it = b.begin();
+ fs::path result;
+ while (a_it != a.end() && b_it != b.end()) {
+ auto& a_part = *a_it;
+ auto& b_part = *b_it;
+ if (a_part != b_part) {
+ break;
+ }
+ result /= a_part;
+ a_it++;
+ b_it++;
+ }
+ return result;
+}
+
+bool Diff(fs::path a, fs::path b) {
+ std::ifstream a_stream(a.c_str(), std::ios::binary | std::ios::ate);
+ std::ifstream b_stream(b.c_str(), std::ios::binary | std::ios::ate);
+ if (!a_stream) {
+ return false;
+ }
+ if (!b_stream) {
+ return false;
+ }
+ if (a_stream.tellg() != b_stream.tellg()) {
+ return false;
+ }
+ a_stream.seekg(0, std::ifstream::beg);
+ b_stream.seekg(0, std::ifstream::beg);
+ return std::equal(std::istreambuf_iterator<char>(a_stream.rdbuf()),
+ std::istreambuf_iterator<char>(),
+ std::istreambuf_iterator<char>(b_stream.rdbuf()));
+}
+
+} // namespace
+
+bool DoValidate(std::filesystem::path zircon_build_root,
+ std::filesystem::path fidlgen_llcpp_path,
+ std::filesystem::path tmp_dir,
+ std::vector<fs::path>* out_dependencies) {
+ fs::remove_all(tmp_dir);
+ fs::create_directories(tmp_dir);
+ auto all_targets = AllTargets(zircon_build_root);
+ auto normalize = [&zircon_build_root](fs::path path) {
+ return fs::weakly_canonical(zircon_build_root / path);
+ };
+ for (const auto& target : all_targets) {
+ for (const auto& source : target.fidl_sources) {
+ out_dependencies->push_back(zircon_build_root / source);
+ }
+ fs::path json = normalize(target.json);
+ fs::path header = normalize(target.header);
+ fs::path source = normalize(target.source);
+ fs::path include_base = normalize(target.include_base);
+ fs::path common = FindCommonPath(header,
+ FindCommonPath(include_base, source));
+ // Generate in an alternative location
+ fs::path tmp = fs::absolute(tmp_dir) / target.name;
+ fs::path alt_header = tmp / fs::relative(header, common);
+ fs::path alt_source = tmp / fs::relative(source, common);
+ fs::path alt_include_base = tmp / fs::relative(include_base, common);
+ std::vector<std::string> args = {
+ "-json",
+ json,
+ "-include-base",
+ alt_include_base,
+ "-header",
+ alt_header,
+ "-source",
+ alt_source
+ };
+ RunCommand(fidlgen_llcpp_path, zircon_build_root, args);
+ if (!Diff(header, alt_header)) {
+ std::cerr << header << " is different from " << alt_header << std::endl;
+ return false;
+ }
+ if (!Diff(source, alt_source)) {
+ std::cerr << source << " is different from " << alt_source << std::endl;
+ return false;
+ }
+ }
+ return true;
+}
+
+void DoUpdate(fs::path zircon_build_root,
+ fs::path fidlgen_llcpp_path,
+ std::vector<fs::path>* out_dependencies) {
+ const auto all_targets = AllTargets(zircon_build_root);
+ for (const auto& target : all_targets) {
+ for (const auto& source : target.fidl_sources) {
+ out_dependencies->push_back(zircon_build_root / source);
+ }
+ std::cout << "Generating low-level C++ bindings for " << target.name
+ << std::endl;
+ RunCommand(fidlgen_llcpp_path, zircon_build_root, target.args);
+ }
+}
diff --git a/tools/fidlgen_llcpp_zircon/llcpp_codegen.h b/tools/fidlgen_llcpp_zircon/llcpp_codegen.h
new file mode 100644
index 0000000..c43a9de7
--- /dev/null
+++ b/tools/fidlgen_llcpp_zircon/llcpp_codegen.h
@@ -0,0 +1,24 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef TOOLS_FIDLGEN_LLCPP_ZIRCON_LLCPP_CODEGEN_H_
+#define TOOLS_FIDLGEN_LLCPP_ZIRCON_LLCPP_CODEGEN_H_
+
+#include <filesystem>
+#include <string>
+#include <vector>
+
+// Validate without touching the checked-in sources.
+// Returns true when sources are up-to-date.
+bool DoValidate(std::filesystem::path zircon_build_root,
+ std::filesystem::path fidlgen_llcpp_path,
+ std::filesystem::path tmp_dir,
+ std::vector<std::filesystem::path>* out_dependencies);
+
+// Update the checked-in sources.
+void DoUpdate(std::filesystem::path zircon_build_root,
+ std::filesystem::path fidlgen_llcpp_path,
+ std::vector<std::filesystem::path>* out_dependencies);
+
+#endif // TOOLS_FIDLGEN_LLCPP_ZIRCON_LLCPP_CODEGEN_H_
diff --git a/tools/fidlgen_llcpp_zircon/main.cc b/tools/fidlgen_llcpp_zircon/main.cc
new file mode 100644
index 0000000..d1cf8d0
--- /dev/null
+++ b/tools/fidlgen_llcpp_zircon/main.cc
@@ -0,0 +1,115 @@
+// Copyright 2019 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <cstdio>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <string.h>
+#include <utility>
+
+#include "llcpp_codegen.h"
+
+namespace fs = std::filesystem;
+
+static void Usage(const char* exe_name) {
+ fprintf(
+ stderr,
+ "Generate or validate the checked-in low-level C++ bindings in zircon.\n"
+ "Usage: %s (validate|update) ZIRCON_BUILDROOT FIDLGEN_LLCPP_PATH "
+ "STAMP DEPFILE TMP_DIR\n"
+ "ZIRCON_BUILDROOT is the root build directory of the Zircon GN build.\n"
+ "FIDLGEN_LLCPP_PATH is the path to the fidlgen_llcpp executable.\n"
+ "STAMP is the output path to a file indicating the success of the tool.\n"
+ "DEPFILE is the output path to a depfile describing the FIDL files\n"
+ "which when updated should trigger a re-run of this tool.\n"
+ "TMP_DIR is a temporary directory for the validator to store generated\n"
+ "bindings. It will be cleared on each run.\n"
+ "\n"
+ "When validate is specified, it will validate that the generated\n"
+ "bindings are up-to-date, exiting with an error if not so.\n"
+ "Files in the source tree are not modified.\n"
+ "\n"
+ "When update is specified, it will regenerate the bindings in\n"
+ "zircon/system/fidl from GN metadata.\n"
+ "\n",
+ exe_name);
+}
+
+enum Args {
+ kPath = 0,
+ kCommand,
+ kZirconBuildRoot,
+ kFidlgenLlcppPath,
+ kStamp,
+ kDepfile,
+ kTmpDir,
+
+ // Number of arguments
+ kSIZE
+};
+
+int main(int argc, char** argv) {
+ if (argc != Args::kSIZE) {
+ std::cerr << argv[Args::kPath] << ": Invalid arguments" << "\n\n";
+ Usage(argv[Args::kPath]);
+ return -1;
+ }
+ // Since we're dealing with two builds, it's less ambiguous if we start with
+ // all absolute paths in the beginning, then convert to relative paths
+ // where required, similar to rebase_path in GN.
+ fs::path zircon_build_root = fs::absolute(argv[Args::kZirconBuildRoot]);
+ fs::path fidlgen_llcpp_path = fs::absolute(argv[Args::kFidlgenLlcppPath]);
+ fs::path stamp_path = fs::absolute(argv[Args::kStamp]);
+ fs::remove(stamp_path);
+ fs::path depfile_path = fs::absolute(argv[Args::kDepfile]);
+ fs::remove(depfile_path);
+ fs::path tmp_dir = fs::absolute(argv[Args::kTmpDir]);
+
+ std::vector<fs::path> dependencies;
+ if (strcmp(argv[Args::kCommand], "validate") == 0) {
+ bool ok = DoValidate(zircon_build_root, fidlgen_llcpp_path, tmp_dir,
+ &dependencies);
+ if (!ok) {
+ std::cerr << "========================================================\n"
+ << "Out-of-date checked-in low-level C++ bindings in Zircon.\n"
+ "Re-run fx build -k 0 tools/fidlgen_llcpp_zircon:update\n"
+ << "========================================================\n";
+ return -1;
+ }
+ } else if (strcmp(argv[Args::kCommand], "update") == 0) {
+ DoUpdate(zircon_build_root, fidlgen_llcpp_path, &dependencies);
+ } else {
+ std::cerr << argv[Args::kPath]
+ << ": Expected validate or update, not "
+ << argv[Args::kCommand]
+ << "\n\n";
+ Usage(argv[Args::kPath]);
+ return -1;
+ }
+ // Generate depfile
+ std::fstream depfile;
+ depfile.open(depfile_path, std::ios::out);
+ if (!depfile) {
+ std::cerr << "Failed to create depfile " << depfile_path << std::endl;
+ return -1;
+ }
+ depfile << fs::relative(stamp_path).string() << ":";
+ for (const auto& dep : dependencies) {
+ depfile << " " << fs::relative(dep).string();
+ }
+ depfile << " " << fs::relative(fidlgen_llcpp_path).string();
+ depfile << std::endl;
+ depfile.close();
+ // Generate stamp file
+ std::fstream stamp;
+ stamp.open(stamp_path, std::ios::out);
+ if (!stamp) {
+ std::cerr << "Failed to stamp " << stamp_path << std::endl;
+ return -1;
+ }
+ stamp.close();
+ return 0;
+}
diff --git a/zircon/public/gn/fidl.gni b/zircon/public/gn/fidl.gni
index 2a5983d..0fb6e28 100644
--- a/zircon/public/gn/fidl.gni
+++ b/zircon/public/gn/fidl.gni
@@ -88,7 +88,6 @@
# default_overrides.
fidl_support = [
"$zx/public/gn/fidl/c.gni",
- "$zx/public/gn/fidl/json.gni",
"$zx/public/gn/fidl/llcpp.gni",
"$zx/public/gn/fidl/tables.gni",
]
@@ -110,16 +109,12 @@
_fidl_gen_fidlc = []
_fidl_gen_templates = []
foreach(gen, _fidl_generators) {
- if (defined(gen.fidl_support_fidlc)) {
- _fidl_gen_fidlc += gen.fidl_support_fidlc
- _fidl_gen_fidlc -= gen.fidl_support_fidlc
- _fidl_gen_fidlc += gen.fidl_support_fidlc
- }
- if (defined(gen.fidl_support_templates)) {
- _fidl_gen_templates += gen.fidl_support_templates
- _fidl_gen_templates -= gen.fidl_support_templates
- _fidl_gen_templates += gen.fidl_support_templates
- }
+ _fidl_gen_fidlc += gen.fidl_support_fidlc
+ _fidl_gen_fidlc -= gen.fidl_support_fidlc
+ _fidl_gen_fidlc += gen.fidl_support_fidlc
+ _fidl_gen_templates += gen.fidl_support_templates
+ _fidl_gen_templates -= gen.fidl_support_templates
+ _fidl_gen_templates += gen.fidl_support_templates
}
# Define a FIDL library and implicitly generate bindings targets.
@@ -291,8 +286,12 @@
# fidlc() uses this file.
generated_file(files_rspfile_target) {
forward_variables_from(invoker, [ "testonly" ])
- deps = [ ":$fidl_target" ]
- outputs = [ files_rspfile ]
+ deps = [
+ ":$fidl_target",
+ ]
+ outputs = [
+ files_rspfile,
+ ]
output_conversion = "list lines"
data_keys = [ "fidl_rspfile" ]
}
@@ -300,7 +299,9 @@
fidlc(gen_target) {
visibility = [ ":*" ]
forward_variables_from(invoker, [ "testonly" ])
- deps = [ ":$fidl_target" ]
+ deps = [
+ ":$fidl_target",
+ ]
outputs = []
args = []
foreach(gen, gens) {
diff --git a/zircon/public/gn/fidl/c.gni b/zircon/public/gn/fidl/c.gni
index 166009c..75261c3 100644
--- a/zircon/public/gn/fidl/c.gni
+++ b/zircon/public/gn/fidl/c.gni
@@ -58,10 +58,6 @@
}
library(library_target) {
- # The library won't actually compile on host but the headers can be used
- # and are used in some unit tests.
- host = true
-
forward_variables_from(invoker,
[
"visibility",
diff --git a/zircon/public/gn/fidl/json.gni b/zircon/public/gn/fidl/json.gni
deleted file mode 100644
index 7bf1805..0000000
--- a/zircon/public/gn/fidl/json.gni
+++ /dev/null
@@ -1,16 +0,0 @@
-# Copyright 2020 The Fuchsia Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-# This tells fidl_library() how to ask fidlc to generate JSON output.
-fidl_support_fidlc = [
- {
- name = "json"
- files = [
- {
- switch = "--json"
- path = "fidl.json"
- },
- ]
- },
-]
diff --git a/zircon/public/gn/fidl/llcpp.gni b/zircon/public/gn/fidl/llcpp.gni
index c1d67e3..f26a3f6 100644
--- a/zircon/public/gn/fidl/llcpp.gni
+++ b/zircon/public/gn/fidl/llcpp.gni
@@ -2,7 +2,6 @@
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
-import("$zx/public/gn/host_tool_action.gni")
import("$zx/public/gn/subtarget_aliases.gni")
# This is the $fidl_support module for "low-level" C++ bindings.
@@ -14,7 +13,20 @@
{
import = "$zx/public/gn/fidl/llcpp.gni"
target = "fidl_llcpp_library"
- fidlc = "json"
+ fidlc = "llcpp"
+ },
+]
+
+# This tells fidl_library() what fidlc outputs fidl_llcpp_library() requires.
+fidl_support_fidlc = [
+ {
+ name = "llcpp"
+ files = [
+ {
+ switch = "--json"
+ path = "fidl.json"
+ },
+ ]
},
]
@@ -24,53 +36,23 @@
# See there for details.
template("fidl_llcpp_library") {
fidl_target = target_name
+ library_target = "$fidl_target.llcpp"
not_needed(invoker, "*")
-
- generator_target = "_fidl_llcpp_library.generate.$fidl_target"
- generator_include_dir = "${invoker.fidlc_gen_dir}/include"
- generator_header_file =
- "$generator_include_dir/${invoker.fidl_path}/llcpp/fidl.h"
- generator_source_file = "${invoker.fidlc_gen_dir}/fidl.cc"
-
- fidlgen_outputs = [
- generator_header_file,
- generator_source_file,
- ]
-
- if (current_toolchain == default_toolchain) {
- fidlc_outputs = invoker.fidlc_outputs
- fidl_json = fidlc_outputs[0]
- assert(fidlc_outputs == [ fidl_json ])
-
- host_tool_action(generator_target) {
- forward_variables_from(invoker, [ "testonly" ])
- visibility = [ ":*" ]
-
- tool = "$zx/tools/fidl:fidlgen_llcpp"
-
- deps = invoker.fidlc_deps
-
- inputs = [ fidl_json ]
- outputs = fidlgen_outputs
-
- args = [
- "-json",
- rebase_path(fidl_json, root_build_dir),
- "-source",
- rebase_path(generator_source_file, root_build_dir),
- "-header",
- rebase_path(generator_header_file, root_build_dir),
- ]
- }
- } else {
- library_target = "$fidl_target.llcpp"
+ if (current_toolchain != default_toolchain) {
+ # TODO(BLD-441): For now the bindings have to be generated and
+ # checked into the source tree. So this is just a normal vanilla
+ # C++ library, except that its sources live in the gen/llcpp/
+ # subdirectory of the fidl_library() target's source directory and
+ # the public headers live in gen/llcpp/include/. The Fuchsia GN
+ # build has code in //TBD to regenerate these files and check that
+ # the copies in the source tree are up to date.
config("_fidl_llcpp_library.config.$library_target") {
visibility = [
":$library_target.headers",
":$library_target.static",
]
- include_dirs = [ generator_include_dir ]
+ include_dirs = [ "gen/llcpp/include" ]
}
library(library_target) {
@@ -81,8 +63,15 @@
])
# Depend on the fidlc generation step and compile what it produces.
- deps = [ ":$generator_target($default_toolchain)" ]
- sources = fidlgen_outputs
+ # TODO(BLD-441): It doesn't actually produce the sources to compile
+ # yet, so depend on the checked-in generated source file explicitly.
+ # When the generation is not directly here, this can just do:
+ # sources = invoker.fidlc_outputs
+ # as done in c.gni.
+ deps = invoker.fidlc_deps
+ sources = [
+ "gen/llcpp/fidl.cc",
+ ]
# Users of the bindings library need the generated headers.
public_configs = [ ":_fidl_llcpp_library.config.$library_target" ]
@@ -90,7 +79,7 @@
# The `.headers` subtarget of a library() only depends on its
# public_deps. But all users of the headers need to depend on the
# generation step too, so put it in public_deps as well.
- public_deps = [ ":$generator_target($default_toolchain)" ]
+ public_deps = invoker.fidlc_deps
# The generated headers of a dependent fidl_library() will #include the
# generated headers for its dependencies' bindings libraries, so those
@@ -110,8 +99,14 @@
deps += [
":$fidl_target.tables",
"$zx/system/ulib/fidl:fidl-llcpp",
- "$zx/system/ulib/fit",
]
+
+ # TODO(BLD-441): Get the metadata below into the dependency graph.
+ # Putting the metadata here directly would duplicate the information
+ # across different toolchains that build the library. So instead,
+ # use a dummy group() in $default_toolchain as a single node to hold
+ # the metadata.
+ deps += [ ":${fidl_target}.llcpp($default_toolchain)" ]
}
# Things normally depend on "fidl/foo:llcpp" rather than
@@ -128,5 +123,46 @@
"llcpp.static",
]
}
+ } else {
+ # TODO(BLD-441): This exists only for the deps above. This generates
+ # metadata for the build_api_module("fidl_gen") at top-level that
+ # informs the //tools/fidlgen_llcpp_zircon scripts what generated sources
+ # need to be updated.
+ # This will go away when the bindings generation is done directly here.
+ group(library_target) {
+ fidlc_outputs = invoker.fidlc_outputs
+ assert(fidlc_outputs == [ fidlc_outputs[0] ])
+ metadata = {
+ fidl_gen = [
+ {
+ label = get_label_info(":$target_name", "label_no_toolchain")
+ fidl_sources = rebase_path(invoker.fidl_sources, root_build_dir)
+ name = invoker.fidl_name
+ target_gen_dir = rebase_path("gen/llcpp", root_build_dir)
+ json = rebase_path(fidlc_outputs[0], root_build_dir)
+ header = "$target_gen_dir/include/${invoker.fidl_path}/llcpp/fidl.h"
+ source = "$target_gen_dir/fidl.cc"
+ include_base = "$target_gen_dir/include"
+
+ # TODO(BLD-442): Could generate an individual response file
+ # here that could be used very simply to drive running fidlgen.
+ # Alternatively, give fidlgen as "JSON response file" feature:
+ # `fidlgen -json-args foo.json` reads a dictionary from the
+ # file. Then we could write that JSON fragment right here in
+ # place of this args list.
+ args = [
+ "-json",
+ json,
+ "-include-base",
+ include_base,
+ "-header",
+ header,
+ "-source",
+ source,
+ ]
+ },
+ ]
+ }
+ }
}
}
diff --git a/zircon/system/dev/test/ddk-lifecycle/gen/llcpp/fidl.cc b/zircon/system/dev/test/ddk-lifecycle/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..e5d4665
--- /dev/null
+++ b/zircon/system/dev/test/ddk-lifecycle/gen/llcpp/fidl.cc
@@ -0,0 +1,830 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/device/lifecycle/test/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace lifecycle {
+namespace test {
+
+void ::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_SubscribeToLifecycle_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_SubscribeToLifecycle_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_SubscribeToLifecycle_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_RemoveChild_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_RemoveChild_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_RemoveChild_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_CompleteChildInit_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_CompleteChildInit_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_CompleteChildInit_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_AddChild_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_AddChild_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_AddChild_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLifecycle_OnChildPreRelease_Ordinal = 0x5b8ccdc000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLifecycle_OnChildPreRelease_GenOrdinal = 0x45196940343cd66alu;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_LifecycleOnChildPreReleaseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_LifecycleOnChildPreReleaseEventTable;
+
+} // namespace
+zx_status_t Lifecycle::SyncClient::HandleEvents(Lifecycle::EventHandlers handlers) {
+ return Lifecycle::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Lifecycle::Call::HandleEvents(::zx::unowned_channel client_end, Lifecycle::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnChildPreReleaseResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnChildPreReleaseResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnChildPreReleaseResponse::MaxNumHandles >= x) {
+ x = OnChildPreReleaseResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kLifecycle_OnChildPreRelease_Ordinal:
+ case kLifecycle_OnChildPreRelease_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnChildPreReleaseResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_child_pre_release(std::move(message->child_id));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Lifecycle::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Lifecycle::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+zx_status_t Lifecycle::SendOnChildPreReleaseEvent(::zx::unowned_channel _chan, uint64_t child_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnChildPreReleaseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<OnChildPreReleaseResponse*>(_write_bytes);
+ Lifecycle::SetTransactionHeaderFor::OnChildPreReleaseResponse(
+ ::fidl::DecodedMessage<OnChildPreReleaseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnChildPreReleaseResponse::PrimarySize,
+ OnChildPreReleaseResponse::PrimarySize)));
+ _response.child_id = std::move(child_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnChildPreReleaseResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<OnChildPreReleaseResponse>(std::move(_response_bytes)));
+}
+
+zx_status_t Lifecycle::SendOnChildPreReleaseEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t child_id) {
+ if (_buffer.capacity() < OnChildPreReleaseResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ auto& _response = *reinterpret_cast<OnChildPreReleaseResponse*>(_buffer.data());
+ Lifecycle::SetTransactionHeaderFor::OnChildPreReleaseResponse(
+ ::fidl::DecodedMessage<OnChildPreReleaseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnChildPreReleaseResponse::PrimarySize,
+ OnChildPreReleaseResponse::PrimarySize)));
+ _response.child_id = std::move(child_id);
+ _buffer.set_actual(sizeof(OnChildPreReleaseResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<OnChildPreReleaseResponse>(std::move(_buffer)));
+}
+
+zx_status_t Lifecycle::SendOnChildPreReleaseEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnChildPreReleaseResponse> params) {
+ Lifecycle::SetTransactionHeaderFor::OnChildPreReleaseResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+
+void Lifecycle::SetTransactionHeaderFor::OnChildPreReleaseResponse(const ::fidl::DecodedMessage<Lifecycle::OnChildPreReleaseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLifecycle_OnChildPreRelease_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_AddChild_Ordinal = 0x1ffc4d2900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_AddChild_GenOrdinal = 0x7ffb522521de57belu;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceAddChildRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceAddChildResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_RemoveChild_Ordinal = 0x60d5f7ec00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_RemoveChild_GenOrdinal = 0x1cf9401a022c96f1lu;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceRemoveChildRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceRemoveChildResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_CompleteChildInit_Ordinal = 0x2d7bf2ad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_CompleteChildInit_GenOrdinal = 0x5004816bf608d448lu;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceCompleteChildInitRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceCompleteChildInitResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_SubscribeToLifecycle_Ordinal = 0x41ac589900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_SubscribeToLifecycle_GenOrdinal = 0x650868f21ef733bflu;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceSubscribeToLifecycleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceSubscribeToLifecycleResponseTable;
+
+} // namespace
+template <>
+TestDevice::ResultOf::AddChild_Impl<TestDevice::AddChildResponse>::AddChild_Impl(::zx::unowned_channel _client_end, bool init_complete, int32_t init_status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddChildRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AddChildRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AddChildRequest*>(_write_bytes);
+ _request.init_complete = std::move(init_complete);
+ _request.init_status = std::move(init_status);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddChildRequest));
+ ::fidl::DecodedMessage<AddChildRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::AddChild(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::AddChild TestDevice::SyncClient::AddChild(bool init_complete, int32_t init_status) {
+ return ResultOf::AddChild(::zx::unowned_channel(this->channel_), std::move(init_complete), std::move(init_status));
+}
+
+TestDevice::ResultOf::AddChild TestDevice::Call::AddChild(::zx::unowned_channel _client_end, bool init_complete, int32_t init_status) {
+ return ResultOf::AddChild(std::move(_client_end), std::move(init_complete), std::move(init_status));
+}
+
+template <>
+TestDevice::UnownedResultOf::AddChild_Impl<TestDevice::AddChildResponse>::AddChild_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool init_complete, int32_t init_status, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AddChildRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AddChildResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AddChildRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AddChildRequest*>(_request_buffer.data());
+ _request.init_complete = std::move(init_complete);
+ _request.init_status = std::move(init_status);
+ _request_buffer.set_actual(sizeof(AddChildRequest));
+ ::fidl::DecodedMessage<AddChildRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::AddChild(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::AddChild TestDevice::SyncClient::AddChild(::fidl::BytePart _request_buffer, bool init_complete, int32_t init_status, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddChild(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(init_complete), std::move(init_status), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::AddChild TestDevice::Call::AddChild(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool init_complete, int32_t init_status, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddChild(std::move(_client_end), std::move(_request_buffer), std::move(init_complete), std::move(init_status), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::AddChildResponse> TestDevice::InPlace::AddChild(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddChildRequest> params, ::fidl::BytePart response_buffer) {
+ TestDevice::SetTransactionHeaderFor::AddChildRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::AddChildResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AddChildRequest, AddChildResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::AddChildResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::RemoveChild_Impl<TestDevice::RemoveChildResponse>::RemoveChild_Impl(::zx::unowned_channel _client_end, uint64_t child_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveChildRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RemoveChildRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RemoveChildRequest*>(_write_bytes);
+ _request.child_id = std::move(child_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RemoveChildRequest));
+ ::fidl::DecodedMessage<RemoveChildRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::RemoveChild(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::RemoveChild TestDevice::SyncClient::RemoveChild(uint64_t child_id) {
+ return ResultOf::RemoveChild(::zx::unowned_channel(this->channel_), std::move(child_id));
+}
+
+TestDevice::ResultOf::RemoveChild TestDevice::Call::RemoveChild(::zx::unowned_channel _client_end, uint64_t child_id) {
+ return ResultOf::RemoveChild(std::move(_client_end), std::move(child_id));
+}
+
+template <>
+TestDevice::UnownedResultOf::RemoveChild_Impl<TestDevice::RemoveChildResponse>::RemoveChild_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RemoveChildRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RemoveChildResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RemoveChildRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RemoveChildRequest*>(_request_buffer.data());
+ _request.child_id = std::move(child_id);
+ _request_buffer.set_actual(sizeof(RemoveChildRequest));
+ ::fidl::DecodedMessage<RemoveChildRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::RemoveChild(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::RemoveChild TestDevice::SyncClient::RemoveChild(::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RemoveChild(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(child_id), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::RemoveChild TestDevice::Call::RemoveChild(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RemoveChild(std::move(_client_end), std::move(_request_buffer), std::move(child_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::RemoveChildResponse> TestDevice::InPlace::RemoveChild(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RemoveChildRequest> params, ::fidl::BytePart response_buffer) {
+ TestDevice::SetTransactionHeaderFor::RemoveChildRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::RemoveChildResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RemoveChildRequest, RemoveChildResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::RemoveChildResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::CompleteChildInit_Impl<TestDevice::CompleteChildInitResponse>::CompleteChildInit_Impl(::zx::unowned_channel _client_end, uint64_t child_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CompleteChildInitRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CompleteChildInitRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CompleteChildInitRequest*>(_write_bytes);
+ _request.child_id = std::move(child_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CompleteChildInitRequest));
+ ::fidl::DecodedMessage<CompleteChildInitRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::CompleteChildInit(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::CompleteChildInit TestDevice::SyncClient::CompleteChildInit(uint64_t child_id) {
+ return ResultOf::CompleteChildInit(::zx::unowned_channel(this->channel_), std::move(child_id));
+}
+
+TestDevice::ResultOf::CompleteChildInit TestDevice::Call::CompleteChildInit(::zx::unowned_channel _client_end, uint64_t child_id) {
+ return ResultOf::CompleteChildInit(std::move(_client_end), std::move(child_id));
+}
+
+template <>
+TestDevice::UnownedResultOf::CompleteChildInit_Impl<TestDevice::CompleteChildInitResponse>::CompleteChildInit_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CompleteChildInitRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CompleteChildInitResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CompleteChildInitRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CompleteChildInitRequest*>(_request_buffer.data());
+ _request.child_id = std::move(child_id);
+ _request_buffer.set_actual(sizeof(CompleteChildInitRequest));
+ ::fidl::DecodedMessage<CompleteChildInitRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::CompleteChildInit(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::CompleteChildInit TestDevice::SyncClient::CompleteChildInit(::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CompleteChildInit(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(child_id), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::CompleteChildInit TestDevice::Call::CompleteChildInit(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CompleteChildInit(std::move(_client_end), std::move(_request_buffer), std::move(child_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::CompleteChildInitResponse> TestDevice::InPlace::CompleteChildInit(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CompleteChildInitRequest> params, ::fidl::BytePart response_buffer) {
+ TestDevice::SetTransactionHeaderFor::CompleteChildInitRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::CompleteChildInitResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CompleteChildInitRequest, CompleteChildInitResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::CompleteChildInitResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::SubscribeToLifecycle_Impl<TestDevice::SubscribeToLifecycleResponse>::SubscribeToLifecycle_Impl(::zx::unowned_channel _client_end, ::zx::channel client) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SubscribeToLifecycleRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SubscribeToLifecycleRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SubscribeToLifecycleRequest*>(_write_bytes);
+ _request.client = std::move(client);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SubscribeToLifecycleRequest));
+ ::fidl::DecodedMessage<SubscribeToLifecycleRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::SubscribeToLifecycle(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::SubscribeToLifecycle TestDevice::SyncClient::SubscribeToLifecycle(::zx::channel client) {
+ return ResultOf::SubscribeToLifecycle(::zx::unowned_channel(this->channel_), std::move(client));
+}
+
+TestDevice::ResultOf::SubscribeToLifecycle TestDevice::Call::SubscribeToLifecycle(::zx::unowned_channel _client_end, ::zx::channel client) {
+ return ResultOf::SubscribeToLifecycle(std::move(_client_end), std::move(client));
+}
+
+template <>
+TestDevice::UnownedResultOf::SubscribeToLifecycle_Impl<TestDevice::SubscribeToLifecycleResponse>::SubscribeToLifecycle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel client, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SubscribeToLifecycleRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SubscribeToLifecycleResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SubscribeToLifecycleRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SubscribeToLifecycleRequest*>(_request_buffer.data());
+ _request.client = std::move(client);
+ _request_buffer.set_actual(sizeof(SubscribeToLifecycleRequest));
+ ::fidl::DecodedMessage<SubscribeToLifecycleRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::SubscribeToLifecycle(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::SubscribeToLifecycle TestDevice::SyncClient::SubscribeToLifecycle(::fidl::BytePart _request_buffer, ::zx::channel client, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SubscribeToLifecycle(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(client), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::SubscribeToLifecycle TestDevice::Call::SubscribeToLifecycle(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel client, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SubscribeToLifecycle(std::move(_client_end), std::move(_request_buffer), std::move(client), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::SubscribeToLifecycleResponse> TestDevice::InPlace::SubscribeToLifecycle(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SubscribeToLifecycleRequest> params, ::fidl::BytePart response_buffer) {
+ TestDevice::SetTransactionHeaderFor::SubscribeToLifecycleRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::SubscribeToLifecycleResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SubscribeToLifecycleRequest, SubscribeToLifecycleResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::SubscribeToLifecycleResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool TestDevice::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kTestDevice_AddChild_Ordinal:
+ case kTestDevice_AddChild_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddChildRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddChild(std::move(message->init_complete), std::move(message->init_status),
+ Interface::AddChildCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_RemoveChild_Ordinal:
+ case kTestDevice_RemoveChild_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RemoveChildRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RemoveChild(std::move(message->child_id),
+ Interface::RemoveChildCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_CompleteChildInit_Ordinal:
+ case kTestDevice_CompleteChildInit_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CompleteChildInitRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CompleteChildInit(std::move(message->child_id),
+ Interface::CompleteChildInitCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_SubscribeToLifecycle_Ordinal:
+ case kTestDevice_SubscribeToLifecycle_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SubscribeToLifecycleRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SubscribeToLifecycle(std::move(message->client),
+ Interface::SubscribeToLifecycleCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool TestDevice::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void TestDevice::Interface::AddChildCompleterBase::Reply(::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddChildResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AddChildResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::AddChildResponse(
+ ::fidl::DecodedMessage<AddChildResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddChildResponse::PrimarySize,
+ AddChildResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::AddChildCompleterBase::ReplySuccess(uint64_t child_id) {
+ TestDevice_AddChild_Response response;
+ response.child_id = std::move(child_id);
+
+ Reply(TestDevice_AddChild_Result::WithResponse(&response));
+}
+void TestDevice::Interface::AddChildCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_AddChild_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::AddChildCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Result result) {
+ if (_buffer.capacity() < AddChildResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AddChildResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::AddChildResponse(
+ ::fidl::DecodedMessage<AddChildResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddChildResponse::PrimarySize,
+ AddChildResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::AddChildCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t child_id) {
+ TestDevice_AddChild_Response response;
+ response.child_id = std::move(child_id);
+
+ Reply(std::move(_buffer), TestDevice_AddChild_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::AddChildCompleterBase::Reply(::fidl::DecodedMessage<AddChildResponse> params) {
+ TestDevice::SetTransactionHeaderFor::AddChildResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::RemoveChildCompleterBase::Reply(::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveChildResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ RemoveChildResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::RemoveChildResponse(
+ ::fidl::DecodedMessage<RemoveChildResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RemoveChildResponse::PrimarySize,
+ RemoveChildResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::RemoveChildCompleterBase::ReplySuccess() {
+ TestDevice_RemoveChild_Response response;
+
+ Reply(TestDevice_RemoveChild_Result::WithResponse(&response));
+}
+void TestDevice::Interface::RemoveChildCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_RemoveChild_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::RemoveChildCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Result result) {
+ if (_buffer.capacity() < RemoveChildResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RemoveChildResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::RemoveChildResponse(
+ ::fidl::DecodedMessage<RemoveChildResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RemoveChildResponse::PrimarySize,
+ RemoveChildResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::RemoveChildCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ TestDevice_RemoveChild_Response response;
+
+ Reply(std::move(_buffer), TestDevice_RemoveChild_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::RemoveChildCompleterBase::Reply(::fidl::DecodedMessage<RemoveChildResponse> params) {
+ TestDevice::SetTransactionHeaderFor::RemoveChildResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::CompleteChildInitCompleterBase::Reply(::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CompleteChildInitResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ CompleteChildInitResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::CompleteChildInitResponse(
+ ::fidl::DecodedMessage<CompleteChildInitResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CompleteChildInitResponse::PrimarySize,
+ CompleteChildInitResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::CompleteChildInitCompleterBase::ReplySuccess() {
+ TestDevice_CompleteChildInit_Response response;
+
+ Reply(TestDevice_CompleteChildInit_Result::WithResponse(&response));
+}
+void TestDevice::Interface::CompleteChildInitCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_CompleteChildInit_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::CompleteChildInitCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Result result) {
+ if (_buffer.capacity() < CompleteChildInitResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleteChildInitResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::CompleteChildInitResponse(
+ ::fidl::DecodedMessage<CompleteChildInitResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CompleteChildInitResponse::PrimarySize,
+ CompleteChildInitResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::CompleteChildInitCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ TestDevice_CompleteChildInit_Response response;
+
+ Reply(std::move(_buffer), TestDevice_CompleteChildInit_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::CompleteChildInitCompleterBase::Reply(::fidl::DecodedMessage<CompleteChildInitResponse> params) {
+ TestDevice::SetTransactionHeaderFor::CompleteChildInitResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::SubscribeToLifecycleCompleterBase::Reply(::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SubscribeToLifecycleResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SubscribeToLifecycleResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::SubscribeToLifecycleResponse(
+ ::fidl::DecodedMessage<SubscribeToLifecycleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SubscribeToLifecycleResponse::PrimarySize,
+ SubscribeToLifecycleResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::SubscribeToLifecycleCompleterBase::ReplySuccess() {
+ TestDevice_SubscribeToLifecycle_Response response;
+
+ Reply(TestDevice_SubscribeToLifecycle_Result::WithResponse(&response));
+}
+void TestDevice::Interface::SubscribeToLifecycleCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_SubscribeToLifecycle_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::SubscribeToLifecycleCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Result result) {
+ if (_buffer.capacity() < SubscribeToLifecycleResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SubscribeToLifecycleResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::SubscribeToLifecycleResponse(
+ ::fidl::DecodedMessage<SubscribeToLifecycleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SubscribeToLifecycleResponse::PrimarySize,
+ SubscribeToLifecycleResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::SubscribeToLifecycleCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ TestDevice_SubscribeToLifecycle_Response response;
+
+ Reply(std::move(_buffer), TestDevice_SubscribeToLifecycle_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::SubscribeToLifecycleCompleterBase::Reply(::fidl::DecodedMessage<SubscribeToLifecycleResponse> params) {
+ TestDevice::SetTransactionHeaderFor::SubscribeToLifecycleResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void TestDevice::SetTransactionHeaderFor::AddChildRequest(const ::fidl::DecodedMessage<TestDevice::AddChildRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_AddChild_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::AddChildResponse(const ::fidl::DecodedMessage<TestDevice::AddChildResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_AddChild_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::RemoveChildRequest(const ::fidl::DecodedMessage<TestDevice::RemoveChildRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_RemoveChild_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::RemoveChildResponse(const ::fidl::DecodedMessage<TestDevice::RemoveChildResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_RemoveChild_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::CompleteChildInitRequest(const ::fidl::DecodedMessage<TestDevice::CompleteChildInitRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_CompleteChildInit_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::CompleteChildInitResponse(const ::fidl::DecodedMessage<TestDevice::CompleteChildInitResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_CompleteChildInit_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::SubscribeToLifecycleRequest(const ::fidl::DecodedMessage<TestDevice::SubscribeToLifecycleRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_SubscribeToLifecycle_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::SubscribeToLifecycleResponse(const ::fidl::DecodedMessage<TestDevice::SubscribeToLifecycleResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_SubscribeToLifecycle_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace test
+} // namespace lifecycle
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/dev/test/ddk-lifecycle/gen/llcpp/include/fuchsia/device/lifecycle/test/llcpp/fidl.h b/zircon/system/dev/test/ddk-lifecycle/gen/llcpp/include/fuchsia/device/lifecycle/test/llcpp/fidl.h
new file mode 100644
index 0000000..4f5b98a
--- /dev/null
+++ b/zircon/system/dev/test/ddk-lifecycle/gen/llcpp/include/fuchsia/device/lifecycle/test/llcpp/fidl.h
@@ -0,0 +1,1221 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace lifecycle {
+namespace test {
+
+struct TestDevice_SubscribeToLifecycle_Response;
+struct TestDevice_SubscribeToLifecycle_Result;
+struct TestDevice_RemoveChild_Response;
+struct TestDevice_RemoveChild_Result;
+struct TestDevice_CompleteChildInit_Response;
+struct TestDevice_CompleteChildInit_Result;
+struct TestDevice_AddChild_Response;
+struct TestDevice_AddChild_Result;
+class Lifecycle;
+class TestDevice;
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDevice_SubscribeToLifecycle_ResultTable;
+
+struct TestDevice_SubscribeToLifecycle_Result {
+ TestDevice_SubscribeToLifecycle_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_SubscribeToLifecycle_Result WithResponse(::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response* val) {
+ TestDevice_SubscribeToLifecycle_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_SubscribeToLifecycle_Result WithErr(int32_t* val) {
+ TestDevice_SubscribeToLifecycle_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDevice_SubscribeToLifecycle_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDevice_RemoveChild_ResultTable;
+
+struct TestDevice_RemoveChild_Result {
+ TestDevice_RemoveChild_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_RemoveChild_Result WithResponse(::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response* val) {
+ TestDevice_RemoveChild_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_RemoveChild_Result WithErr(int32_t* val) {
+ TestDevice_RemoveChild_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDevice_RemoveChild_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDevice_CompleteChildInit_ResultTable;
+
+struct TestDevice_CompleteChildInit_Result {
+ TestDevice_CompleteChildInit_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_CompleteChildInit_Result WithResponse(::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response* val) {
+ TestDevice_CompleteChildInit_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_CompleteChildInit_Result WithErr(int32_t* val) {
+ TestDevice_CompleteChildInit_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDevice_CompleteChildInit_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDevice_AddChild_ResultTable;
+
+struct TestDevice_AddChild_Result {
+ TestDevice_AddChild_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_AddChild_Result WithResponse(::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response* val) {
+ TestDevice_AddChild_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_AddChild_Result WithErr(int32_t* val) {
+ TestDevice_AddChild_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDevice_AddChild_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDevice_SubscribeToLifecycle_ResponseTable;
+
+struct TestDevice_SubscribeToLifecycle_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDevice_SubscribeToLifecycle_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDevice_RemoveChild_ResponseTable;
+
+struct TestDevice_RemoveChild_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDevice_RemoveChild_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDevice_CompleteChildInit_ResponseTable;
+
+struct TestDevice_CompleteChildInit_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDevice_CompleteChildInit_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDevice_AddChild_ResponseTable;
+
+struct TestDevice_AddChild_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDevice_AddChild_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t child_id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_LifecycleOnChildPreReleaseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_LifecycleOnChildPreReleaseEventTable;
+
+class Lifecycle final {
+ Lifecycle() = delete;
+ public:
+
+ struct OnChildPreReleaseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t child_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_LifecycleOnChildPreReleaseEventTable;
+ 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 EventHandlers {
+ // Sent when the ChildPreRelease hook is called.
+ fit::callback<zx_status_t(uint64_t child_id)> on_child_pre_release;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+
+ public:
+ };
+
+ // 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:
+
+ public:
+ };
+
+ 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_; }
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Lifecycle;
+ using _Base = ::fidl::CompleterBase;
+
+ };
+
+ // 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);
+ }
+
+ // Sent when the ChildPreRelease hook is called.
+ static zx_status_t SendOnChildPreReleaseEvent(::zx::unowned_channel _chan, uint64_t child_id);
+
+ // Sent when the ChildPreRelease hook is called.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnChildPreReleaseEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t child_id);
+
+ // Sent when the ChildPreRelease hook is called.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnChildPreReleaseEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnChildPreReleaseResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void OnChildPreReleaseResponse(const ::fidl::DecodedMessage<Lifecycle::OnChildPreReleaseResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceAddChildRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceAddChildResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceRemoveChildRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceRemoveChildResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceCompleteChildInitRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceCompleteChildInitResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceSubscribeToLifecycleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_lifecycle_test_TestDeviceSubscribeToLifecycleResponseTable;
+
+class TestDevice final {
+ TestDevice() = delete;
+ public:
+
+ struct AddChildResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDeviceAddChildResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AddChildRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool init_complete;
+ int32_t init_status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDeviceAddChildRequestTable;
+ 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 = AddChildResponse;
+ };
+
+ struct RemoveChildResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDeviceRemoveChildResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RemoveChildRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t child_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDeviceRemoveChildRequestTable;
+ 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 = RemoveChildResponse;
+ };
+
+ struct CompleteChildInitResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDeviceCompleteChildInitResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct CompleteChildInitRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t child_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDeviceCompleteChildInitRequestTable;
+ 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 = CompleteChildInitResponse;
+ };
+
+ struct SubscribeToLifecycleResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDeviceSubscribeToLifecycleResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SubscribeToLifecycleRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel client;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_lifecycle_test_TestDeviceSubscribeToLifecycleRequestTable;
+ 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 = SubscribeToLifecycleResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class AddChild_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AddChild_Impl(::zx::unowned_channel _client_end, bool init_complete, int32_t init_status);
+ ~AddChild_Impl() = default;
+ AddChild_Impl(AddChild_Impl&& other) = default;
+ AddChild_Impl& operator=(AddChild_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 RemoveChild_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RemoveChild_Impl(::zx::unowned_channel _client_end, uint64_t child_id);
+ ~RemoveChild_Impl() = default;
+ RemoveChild_Impl(RemoveChild_Impl&& other) = default;
+ RemoveChild_Impl& operator=(RemoveChild_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 CompleteChildInit_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CompleteChildInit_Impl(::zx::unowned_channel _client_end, uint64_t child_id);
+ ~CompleteChildInit_Impl() = default;
+ CompleteChildInit_Impl(CompleteChildInit_Impl&& other) = default;
+ CompleteChildInit_Impl& operator=(CompleteChildInit_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 SubscribeToLifecycle_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SubscribeToLifecycle_Impl(::zx::unowned_channel _client_end, ::zx::channel client);
+ ~SubscribeToLifecycle_Impl() = default;
+ SubscribeToLifecycle_Impl(SubscribeToLifecycle_Impl&& other) = default;
+ SubscribeToLifecycle_Impl& operator=(SubscribeToLifecycle_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 AddChild = AddChild_Impl<AddChildResponse>;
+ using RemoveChild = RemoveChild_Impl<RemoveChildResponse>;
+ using CompleteChildInit = CompleteChildInit_Impl<CompleteChildInitResponse>;
+ using SubscribeToLifecycle = SubscribeToLifecycle_Impl<SubscribeToLifecycleResponse>;
+ };
+
+ // 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 AddChild_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AddChild_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool init_complete, int32_t init_status, ::fidl::BytePart _response_buffer);
+ ~AddChild_Impl() = default;
+ AddChild_Impl(AddChild_Impl&& other) = default;
+ AddChild_Impl& operator=(AddChild_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 RemoveChild_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RemoveChild_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer);
+ ~RemoveChild_Impl() = default;
+ RemoveChild_Impl(RemoveChild_Impl&& other) = default;
+ RemoveChild_Impl& operator=(RemoveChild_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 CompleteChildInit_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CompleteChildInit_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer);
+ ~CompleteChildInit_Impl() = default;
+ CompleteChildInit_Impl(CompleteChildInit_Impl&& other) = default;
+ CompleteChildInit_Impl& operator=(CompleteChildInit_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 SubscribeToLifecycle_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SubscribeToLifecycle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel client, ::fidl::BytePart _response_buffer);
+ ~SubscribeToLifecycle_Impl() = default;
+ SubscribeToLifecycle_Impl(SubscribeToLifecycle_Impl&& other) = default;
+ SubscribeToLifecycle_Impl& operator=(SubscribeToLifecycle_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 AddChild = AddChild_Impl<AddChildResponse>;
+ using RemoveChild = RemoveChild_Impl<RemoveChildResponse>;
+ using CompleteChildInit = CompleteChildInit_Impl<CompleteChildInitResponse>;
+ using SubscribeToLifecycle = SubscribeToLifecycle_Impl<SubscribeToLifecycleResponse>;
+ };
+
+ 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_; }
+
+ // Adds a child device and returns a unique |id| for the created device.
+ // |complete_init| specifies whether the init hook should be replied to immediately,
+ // or completed later by the caller with |CompleteChildInit|.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AddChild AddChild(bool init_complete, int32_t init_status);
+
+ // Adds a child device and returns a unique |id| for the created device.
+ // |complete_init| specifies whether the init hook should be replied to immediately,
+ // or completed later by the caller with |CompleteChildInit|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddChild AddChild(::fidl::BytePart _request_buffer, bool init_complete, int32_t init_status, ::fidl::BytePart _response_buffer);
+
+ // Removes the child device of the given |id|.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RemoveChild RemoveChild(uint64_t child_id);
+
+ // Removes the child device of the given |id|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RemoveChild RemoveChild(::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer);
+
+ // Replies to the child init hook.
+ // Returns an error if the child has no pending init.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CompleteChildInit CompleteChildInit(uint64_t child_id);
+
+ // Replies to the child init hook.
+ // Returns an error if the child has no pending init.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CompleteChildInit CompleteChildInit(::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer);
+
+ // Registers the client for device lifecycle events.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SubscribeToLifecycle SubscribeToLifecycle(::zx::channel client);
+
+ // Registers the client for device lifecycle events.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SubscribeToLifecycle SubscribeToLifecycle(::fidl::BytePart _request_buffer, ::zx::channel client, ::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:
+
+ // Adds a child device and returns a unique |id| for the created device.
+ // |complete_init| specifies whether the init hook should be replied to immediately,
+ // or completed later by the caller with |CompleteChildInit|.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AddChild AddChild(::zx::unowned_channel _client_end, bool init_complete, int32_t init_status);
+
+ // Adds a child device and returns a unique |id| for the created device.
+ // |complete_init| specifies whether the init hook should be replied to immediately,
+ // or completed later by the caller with |CompleteChildInit|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddChild AddChild(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool init_complete, int32_t init_status, ::fidl::BytePart _response_buffer);
+
+ // Removes the child device of the given |id|.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RemoveChild RemoveChild(::zx::unowned_channel _client_end, uint64_t child_id);
+
+ // Removes the child device of the given |id|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RemoveChild RemoveChild(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer);
+
+ // Replies to the child init hook.
+ // Returns an error if the child has no pending init.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CompleteChildInit CompleteChildInit(::zx::unowned_channel _client_end, uint64_t child_id);
+
+ // Replies to the child init hook.
+ // Returns an error if the child has no pending init.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CompleteChildInit CompleteChildInit(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t child_id, ::fidl::BytePart _response_buffer);
+
+ // Registers the client for device lifecycle events.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SubscribeToLifecycle SubscribeToLifecycle(::zx::unowned_channel _client_end, ::zx::channel client);
+
+ // Registers the client for device lifecycle events.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SubscribeToLifecycle SubscribeToLifecycle(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel client, ::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:
+
+ // Adds a child device and returns a unique |id| for the created device.
+ // |complete_init| specifies whether the init hook should be replied to immediately,
+ // or completed later by the caller with |CompleteChildInit|.
+ static ::fidl::DecodeResult<AddChildResponse> AddChild(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddChildRequest> params, ::fidl::BytePart response_buffer);
+
+ // Removes the child device of the given |id|.
+ static ::fidl::DecodeResult<RemoveChildResponse> RemoveChild(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RemoveChildRequest> params, ::fidl::BytePart response_buffer);
+
+ // Replies to the child init hook.
+ // Returns an error if the child has no pending init.
+ static ::fidl::DecodeResult<CompleteChildInitResponse> CompleteChildInit(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CompleteChildInitRequest> params, ::fidl::BytePart response_buffer);
+
+ // Registers the client for device lifecycle events.
+ static ::fidl::DecodeResult<SubscribeToLifecycleResponse> SubscribeToLifecycle(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SubscribeToLifecycleRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = TestDevice;
+ using _Base = ::fidl::CompleterBase;
+
+ class AddChildCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Result result);
+ void ReplySuccess(uint64_t child_id);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint64_t child_id);
+ void Reply(::fidl::DecodedMessage<AddChildResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AddChildCompleter = ::fidl::Completer<AddChildCompleterBase>;
+
+ virtual void AddChild(bool init_complete, int32_t init_status, AddChildCompleter::Sync _completer) = 0;
+
+ class RemoveChildCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<RemoveChildResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RemoveChildCompleter = ::fidl::Completer<RemoveChildCompleterBase>;
+
+ virtual void RemoveChild(uint64_t child_id, RemoveChildCompleter::Sync _completer) = 0;
+
+ class CompleteChildInitCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<CompleteChildInitResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CompleteChildInitCompleter = ::fidl::Completer<CompleteChildInitCompleterBase>;
+
+ virtual void CompleteChildInit(uint64_t child_id, CompleteChildInitCompleter::Sync _completer) = 0;
+
+ class SubscribeToLifecycleCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SubscribeToLifecycleResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SubscribeToLifecycleCompleter = ::fidl::Completer<SubscribeToLifecycleCompleterBase>;
+
+ virtual void SubscribeToLifecycle(::zx::channel client, SubscribeToLifecycleCompleter::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 AddChildRequest(const ::fidl::DecodedMessage<TestDevice::AddChildRequest>& _msg);
+ static void AddChildResponse(const ::fidl::DecodedMessage<TestDevice::AddChildResponse>& _msg);
+ static void RemoveChildRequest(const ::fidl::DecodedMessage<TestDevice::RemoveChildRequest>& _msg);
+ static void RemoveChildResponse(const ::fidl::DecodedMessage<TestDevice::RemoveChildResponse>& _msg);
+ static void CompleteChildInitRequest(const ::fidl::DecodedMessage<TestDevice::CompleteChildInitRequest>& _msg);
+ static void CompleteChildInitResponse(const ::fidl::DecodedMessage<TestDevice::CompleteChildInitResponse>& _msg);
+ static void SubscribeToLifecycleRequest(const ::fidl::DecodedMessage<TestDevice::SubscribeToLifecycleRequest>& _msg);
+ static void SubscribeToLifecycleResponse(const ::fidl::DecodedMessage<TestDevice::SubscribeToLifecycleResponse>& _msg);
+ };
+};
+
+} // namespace test
+} // namespace lifecycle
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response) == ::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::lifecycle::test::TestDevice_SubscribeToLifecycle_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response) == ::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::lifecycle::test::TestDevice_RemoveChild_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response) == ::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::lifecycle::test::TestDevice_CompleteChildInit_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response, child_id) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response) == ::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::lifecycle::test::TestDevice_AddChild_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::Lifecycle::OnChildPreReleaseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::Lifecycle::OnChildPreReleaseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::Lifecycle::OnChildPreReleaseResponse)
+ == ::llcpp::fuchsia::device::lifecycle::test::Lifecycle::OnChildPreReleaseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::Lifecycle::OnChildPreReleaseResponse, child_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildRequest)
+ == ::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildRequest, init_complete) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildRequest, init_status) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildResponse)
+ == ::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::AddChildResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildRequest)
+ == ::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildRequest, child_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildResponse)
+ == ::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::RemoveChildResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitRequest)
+ == ::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitRequest, child_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitResponse)
+ == ::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::CompleteChildInitResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleRequest)
+ == ::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleRequest, client) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleResponse)
+ == ::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::lifecycle::test::TestDevice::SubscribeToLifecycleResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/dev/test/ddk-power/gen/llcpp/fidl.cc b/zircon/system/dev/test/ddk-power/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..d2ef957
--- /dev/null
+++ b/zircon/system/dev/test/ddk-power/gen/llcpp/fidl.cc
@@ -0,0 +1,833 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/device/power/test/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace power {
+namespace test {
+
+void ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_GetCurrentDevicePowerState_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_GetCurrentDevicePowerState_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_GetCurrentDevicePowerState_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_GetCurrentDeviceAutoSuspendConfig_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_GetCurrentDeviceAutoSuspendConfig_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_GetCurrentDeviceAutoSuspendConfig_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_GetCurrentSuspendReason_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_GetCurrentSuspendReason_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_GetCurrentSuspendReason_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_GetCurrentDevicePerformanceState_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_GetCurrentDevicePerformanceState_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_GetCurrentDevicePerformanceState_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_AddDeviceWithPowerArgs_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_AddDeviceWithPowerArgs_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_AddDeviceWithPowerArgs_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_AddDeviceWithPowerArgs_Ordinal = 0x5d89a15400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_AddDeviceWithPowerArgs_GenOrdinal = 0x6f4b31b6d68abb48lu;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceAddDeviceWithPowerArgsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceAddDeviceWithPowerArgsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetCurrentDevicePowerState_Ordinal = 0x724b2ef700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetCurrentDevicePowerState_GenOrdinal = 0x15ff1a2b10784103lu;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePowerStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePowerStateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetCurrentSuspendReason_Ordinal = 0x4a634f300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetCurrentSuspendReason_GenOrdinal = 0x5a021abc7938e00alu;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentSuspendReasonRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentSuspendReasonResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetCurrentDevicePerformanceState_Ordinal = 0x3ee16b9700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetCurrentDevicePerformanceState_GenOrdinal = 0x3f88876404832324lu;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePerformanceStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePerformanceStateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetCurrentDeviceAutoSuspendConfig_Ordinal = 0x109bde2f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetCurrentDeviceAutoSuspendConfig_GenOrdinal = 0x5a245a86e6eaba4blu;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDeviceAutoSuspendConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDeviceAutoSuspendConfigResponseTable;
+
+} // namespace
+template <>
+TestDevice::ResultOf::AddDeviceWithPowerArgs_Impl<TestDevice::AddDeviceWithPowerArgsResponse>::AddDeviceWithPowerArgs_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceWithPowerArgsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddDeviceWithPowerArgsRequest _request = {};
+ _request.info = std::move(info);
+ _request.perf_state_info = std::move(perf_state_info);
+ _request.make_visible = std::move(make_visible);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddDeviceWithPowerArgsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ TestDevice::InPlace::AddDeviceWithPowerArgs(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::AddDeviceWithPowerArgs TestDevice::SyncClient::AddDeviceWithPowerArgs(::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible) {
+ return ResultOf::AddDeviceWithPowerArgs(::zx::unowned_channel(this->channel_), std::move(info), std::move(perf_state_info), std::move(make_visible));
+}
+
+TestDevice::ResultOf::AddDeviceWithPowerArgs TestDevice::Call::AddDeviceWithPowerArgs(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible) {
+ return ResultOf::AddDeviceWithPowerArgs(std::move(_client_end), std::move(info), std::move(perf_state_info), std::move(make_visible));
+}
+
+template <>
+TestDevice::UnownedResultOf::AddDeviceWithPowerArgs_Impl<TestDevice::AddDeviceWithPowerArgsResponse>::AddDeviceWithPowerArgs_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AddDeviceWithPowerArgsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AddDeviceWithPowerArgsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ AddDeviceWithPowerArgsRequest _request = {};
+ _request.info = std::move(info);
+ _request.perf_state_info = std::move(perf_state_info);
+ _request.make_visible = std::move(make_visible);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddDeviceWithPowerArgsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ TestDevice::InPlace::AddDeviceWithPowerArgs(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::AddDeviceWithPowerArgs TestDevice::SyncClient::AddDeviceWithPowerArgs(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddDeviceWithPowerArgs(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(info), std::move(perf_state_info), std::move(make_visible), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::AddDeviceWithPowerArgs TestDevice::Call::AddDeviceWithPowerArgs(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddDeviceWithPowerArgs(std::move(_client_end), std::move(_request_buffer), std::move(info), std::move(perf_state_info), std::move(make_visible), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::AddDeviceWithPowerArgsResponse> TestDevice::InPlace::AddDeviceWithPowerArgs(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceWithPowerArgsRequest> params, ::fidl::BytePart response_buffer) {
+ TestDevice::SetTransactionHeaderFor::AddDeviceWithPowerArgsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::AddDeviceWithPowerArgsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AddDeviceWithPowerArgsRequest, AddDeviceWithPowerArgsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::AddDeviceWithPowerArgsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::GetCurrentDevicePowerState_Impl<TestDevice::GetCurrentDevicePowerStateResponse>::GetCurrentDevicePowerState_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCurrentDevicePowerStateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetCurrentDevicePowerStateRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCurrentDevicePowerStateRequest));
+ ::fidl::DecodedMessage<GetCurrentDevicePowerStateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::GetCurrentDevicePowerState(std::move(_client_end), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::GetCurrentDevicePowerState TestDevice::SyncClient::GetCurrentDevicePowerState() {
+ return ResultOf::GetCurrentDevicePowerState(::zx::unowned_channel(this->channel_));
+}
+
+TestDevice::ResultOf::GetCurrentDevicePowerState TestDevice::Call::GetCurrentDevicePowerState(::zx::unowned_channel _client_end) {
+ return ResultOf::GetCurrentDevicePowerState(std::move(_client_end));
+}
+
+template <>
+TestDevice::UnownedResultOf::GetCurrentDevicePowerState_Impl<TestDevice::GetCurrentDevicePowerStateResponse>::GetCurrentDevicePowerState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetCurrentDevicePowerStateRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetCurrentDevicePowerStateRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetCurrentDevicePowerStateRequest));
+ ::fidl::DecodedMessage<GetCurrentDevicePowerStateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::GetCurrentDevicePowerState(std::move(_client_end), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::GetCurrentDevicePowerState TestDevice::SyncClient::GetCurrentDevicePowerState(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCurrentDevicePowerState(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::GetCurrentDevicePowerState TestDevice::Call::GetCurrentDevicePowerState(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCurrentDevicePowerState(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::GetCurrentDevicePowerStateResponse> TestDevice::InPlace::GetCurrentDevicePowerState(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetCurrentDevicePowerStateRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetCurrentDevicePowerStateRequest> params(std::move(_request_buffer));
+ TestDevice::SetTransactionHeaderFor::GetCurrentDevicePowerStateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetCurrentDevicePowerStateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetCurrentDevicePowerStateRequest, GetCurrentDevicePowerStateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetCurrentDevicePowerStateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::GetCurrentSuspendReason_Impl<TestDevice::GetCurrentSuspendReasonResponse>::GetCurrentSuspendReason_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCurrentSuspendReasonRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetCurrentSuspendReasonRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCurrentSuspendReasonRequest));
+ ::fidl::DecodedMessage<GetCurrentSuspendReasonRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::GetCurrentSuspendReason(std::move(_client_end), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::GetCurrentSuspendReason TestDevice::SyncClient::GetCurrentSuspendReason() {
+ return ResultOf::GetCurrentSuspendReason(::zx::unowned_channel(this->channel_));
+}
+
+TestDevice::ResultOf::GetCurrentSuspendReason TestDevice::Call::GetCurrentSuspendReason(::zx::unowned_channel _client_end) {
+ return ResultOf::GetCurrentSuspendReason(std::move(_client_end));
+}
+
+template <>
+TestDevice::UnownedResultOf::GetCurrentSuspendReason_Impl<TestDevice::GetCurrentSuspendReasonResponse>::GetCurrentSuspendReason_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetCurrentSuspendReasonRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetCurrentSuspendReasonRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetCurrentSuspendReasonRequest));
+ ::fidl::DecodedMessage<GetCurrentSuspendReasonRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::GetCurrentSuspendReason(std::move(_client_end), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::GetCurrentSuspendReason TestDevice::SyncClient::GetCurrentSuspendReason(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCurrentSuspendReason(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::GetCurrentSuspendReason TestDevice::Call::GetCurrentSuspendReason(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCurrentSuspendReason(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::GetCurrentSuspendReasonResponse> TestDevice::InPlace::GetCurrentSuspendReason(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetCurrentSuspendReasonRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetCurrentSuspendReasonRequest> params(std::move(_request_buffer));
+ TestDevice::SetTransactionHeaderFor::GetCurrentSuspendReasonRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetCurrentSuspendReasonResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetCurrentSuspendReasonRequest, GetCurrentSuspendReasonResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetCurrentSuspendReasonResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::GetCurrentDevicePerformanceState_Impl<TestDevice::GetCurrentDevicePerformanceStateResponse>::GetCurrentDevicePerformanceState_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCurrentDevicePerformanceStateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetCurrentDevicePerformanceStateRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCurrentDevicePerformanceStateRequest));
+ ::fidl::DecodedMessage<GetCurrentDevicePerformanceStateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::GetCurrentDevicePerformanceState(std::move(_client_end), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::GetCurrentDevicePerformanceState TestDevice::SyncClient::GetCurrentDevicePerformanceState() {
+ return ResultOf::GetCurrentDevicePerformanceState(::zx::unowned_channel(this->channel_));
+}
+
+TestDevice::ResultOf::GetCurrentDevicePerformanceState TestDevice::Call::GetCurrentDevicePerformanceState(::zx::unowned_channel _client_end) {
+ return ResultOf::GetCurrentDevicePerformanceState(std::move(_client_end));
+}
+
+template <>
+TestDevice::UnownedResultOf::GetCurrentDevicePerformanceState_Impl<TestDevice::GetCurrentDevicePerformanceStateResponse>::GetCurrentDevicePerformanceState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetCurrentDevicePerformanceStateRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetCurrentDevicePerformanceStateRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetCurrentDevicePerformanceStateRequest));
+ ::fidl::DecodedMessage<GetCurrentDevicePerformanceStateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::GetCurrentDevicePerformanceState(std::move(_client_end), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::GetCurrentDevicePerformanceState TestDevice::SyncClient::GetCurrentDevicePerformanceState(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCurrentDevicePerformanceState(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::GetCurrentDevicePerformanceState TestDevice::Call::GetCurrentDevicePerformanceState(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCurrentDevicePerformanceState(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::GetCurrentDevicePerformanceStateResponse> TestDevice::InPlace::GetCurrentDevicePerformanceState(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetCurrentDevicePerformanceStateRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetCurrentDevicePerformanceStateRequest> params(std::move(_request_buffer));
+ TestDevice::SetTransactionHeaderFor::GetCurrentDevicePerformanceStateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetCurrentDevicePerformanceStateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetCurrentDevicePerformanceStateRequest, GetCurrentDevicePerformanceStateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetCurrentDevicePerformanceStateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::GetCurrentDeviceAutoSuspendConfig_Impl<TestDevice::GetCurrentDeviceAutoSuspendConfigResponse>::GetCurrentDeviceAutoSuspendConfig_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCurrentDeviceAutoSuspendConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetCurrentDeviceAutoSuspendConfigRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCurrentDeviceAutoSuspendConfigRequest));
+ ::fidl::DecodedMessage<GetCurrentDeviceAutoSuspendConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::GetCurrentDeviceAutoSuspendConfig(std::move(_client_end), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::GetCurrentDeviceAutoSuspendConfig TestDevice::SyncClient::GetCurrentDeviceAutoSuspendConfig() {
+ return ResultOf::GetCurrentDeviceAutoSuspendConfig(::zx::unowned_channel(this->channel_));
+}
+
+TestDevice::ResultOf::GetCurrentDeviceAutoSuspendConfig TestDevice::Call::GetCurrentDeviceAutoSuspendConfig(::zx::unowned_channel _client_end) {
+ return ResultOf::GetCurrentDeviceAutoSuspendConfig(std::move(_client_end));
+}
+
+template <>
+TestDevice::UnownedResultOf::GetCurrentDeviceAutoSuspendConfig_Impl<TestDevice::GetCurrentDeviceAutoSuspendConfigResponse>::GetCurrentDeviceAutoSuspendConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetCurrentDeviceAutoSuspendConfigRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetCurrentDeviceAutoSuspendConfigRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetCurrentDeviceAutoSuspendConfigRequest));
+ ::fidl::DecodedMessage<GetCurrentDeviceAutoSuspendConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::GetCurrentDeviceAutoSuspendConfig(std::move(_client_end), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::GetCurrentDeviceAutoSuspendConfig TestDevice::SyncClient::GetCurrentDeviceAutoSuspendConfig(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCurrentDeviceAutoSuspendConfig(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::GetCurrentDeviceAutoSuspendConfig TestDevice::Call::GetCurrentDeviceAutoSuspendConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCurrentDeviceAutoSuspendConfig(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::GetCurrentDeviceAutoSuspendConfigResponse> TestDevice::InPlace::GetCurrentDeviceAutoSuspendConfig(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetCurrentDeviceAutoSuspendConfigRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetCurrentDeviceAutoSuspendConfigRequest> params(std::move(_request_buffer));
+ TestDevice::SetTransactionHeaderFor::GetCurrentDeviceAutoSuspendConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetCurrentDeviceAutoSuspendConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetCurrentDeviceAutoSuspendConfigRequest, GetCurrentDeviceAutoSuspendConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetCurrentDeviceAutoSuspendConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool TestDevice::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kTestDevice_AddDeviceWithPowerArgs_Ordinal:
+ case kTestDevice_AddDeviceWithPowerArgs_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddDeviceWithPowerArgsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddDeviceWithPowerArgs(std::move(message->info), std::move(message->perf_state_info), std::move(message->make_visible),
+ Interface::AddDeviceWithPowerArgsCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_GetCurrentDevicePowerState_Ordinal:
+ case kTestDevice_GetCurrentDevicePowerState_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetCurrentDevicePowerStateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetCurrentDevicePowerState(
+ Interface::GetCurrentDevicePowerStateCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_GetCurrentSuspendReason_Ordinal:
+ case kTestDevice_GetCurrentSuspendReason_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetCurrentSuspendReasonRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetCurrentSuspendReason(
+ Interface::GetCurrentSuspendReasonCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_GetCurrentDevicePerformanceState_Ordinal:
+ case kTestDevice_GetCurrentDevicePerformanceState_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetCurrentDevicePerformanceStateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetCurrentDevicePerformanceState(
+ Interface::GetCurrentDevicePerformanceStateCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_GetCurrentDeviceAutoSuspendConfig_Ordinal:
+ case kTestDevice_GetCurrentDeviceAutoSuspendConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetCurrentDeviceAutoSuspendConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetCurrentDeviceAutoSuspendConfig(
+ Interface::GetCurrentDeviceAutoSuspendConfigCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool TestDevice::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void TestDevice::Interface::AddDeviceWithPowerArgsCompleterBase::Reply(::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceWithPowerArgsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AddDeviceWithPowerArgsResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::AddDeviceWithPowerArgsResponse(
+ ::fidl::DecodedMessage<AddDeviceWithPowerArgsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddDeviceWithPowerArgsResponse::PrimarySize,
+ AddDeviceWithPowerArgsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::AddDeviceWithPowerArgsCompleterBase::ReplySuccess() {
+ TestDevice_AddDeviceWithPowerArgs_Response response;
+
+ Reply(TestDevice_AddDeviceWithPowerArgs_Result::WithResponse(&response));
+}
+void TestDevice::Interface::AddDeviceWithPowerArgsCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_AddDeviceWithPowerArgs_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::AddDeviceWithPowerArgsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Result result) {
+ if (_buffer.capacity() < AddDeviceWithPowerArgsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AddDeviceWithPowerArgsResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::AddDeviceWithPowerArgsResponse(
+ ::fidl::DecodedMessage<AddDeviceWithPowerArgsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddDeviceWithPowerArgsResponse::PrimarySize,
+ AddDeviceWithPowerArgsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::AddDeviceWithPowerArgsCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ TestDevice_AddDeviceWithPowerArgs_Response response;
+
+ Reply(std::move(_buffer), TestDevice_AddDeviceWithPowerArgs_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::AddDeviceWithPowerArgsCompleterBase::Reply(::fidl::DecodedMessage<AddDeviceWithPowerArgsResponse> params) {
+ TestDevice::SetTransactionHeaderFor::AddDeviceWithPowerArgsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::GetCurrentDevicePowerStateCompleterBase::Reply(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCurrentDevicePowerStateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetCurrentDevicePowerStateResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetCurrentDevicePowerStateResponse(
+ ::fidl::DecodedMessage<GetCurrentDevicePowerStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCurrentDevicePowerStateResponse::PrimarySize,
+ GetCurrentDevicePowerStateResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetCurrentDevicePowerStateCompleterBase::ReplySuccess(::llcpp::fuchsia::device::DevicePowerState cur_state) {
+ TestDevice_GetCurrentDevicePowerState_Response response;
+ response.cur_state = std::move(cur_state);
+
+ Reply(TestDevice_GetCurrentDevicePowerState_Result::WithResponse(&response));
+}
+void TestDevice::Interface::GetCurrentDevicePowerStateCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_GetCurrentDevicePowerState_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::GetCurrentDevicePowerStateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Result result) {
+ if (_buffer.capacity() < GetCurrentDevicePowerStateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetCurrentDevicePowerStateResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetCurrentDevicePowerStateResponse(
+ ::fidl::DecodedMessage<GetCurrentDevicePowerStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCurrentDevicePowerStateResponse::PrimarySize,
+ GetCurrentDevicePowerStateResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetCurrentDevicePowerStateCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::DevicePowerState cur_state) {
+ TestDevice_GetCurrentDevicePowerState_Response response;
+ response.cur_state = std::move(cur_state);
+
+ Reply(std::move(_buffer), TestDevice_GetCurrentDevicePowerState_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::GetCurrentDevicePowerStateCompleterBase::Reply(::fidl::DecodedMessage<GetCurrentDevicePowerStateResponse> params) {
+ TestDevice::SetTransactionHeaderFor::GetCurrentDevicePowerStateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::GetCurrentSuspendReasonCompleterBase::Reply(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCurrentSuspendReasonResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetCurrentSuspendReasonResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetCurrentSuspendReasonResponse(
+ ::fidl::DecodedMessage<GetCurrentSuspendReasonResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCurrentSuspendReasonResponse::PrimarySize,
+ GetCurrentSuspendReasonResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetCurrentSuspendReasonCompleterBase::ReplySuccess(uint8_t cur_suspend_reason) {
+ TestDevice_GetCurrentSuspendReason_Response response;
+ response.cur_suspend_reason = std::move(cur_suspend_reason);
+
+ Reply(TestDevice_GetCurrentSuspendReason_Result::WithResponse(&response));
+}
+void TestDevice::Interface::GetCurrentSuspendReasonCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_GetCurrentSuspendReason_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::GetCurrentSuspendReasonCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Result result) {
+ if (_buffer.capacity() < GetCurrentSuspendReasonResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetCurrentSuspendReasonResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetCurrentSuspendReasonResponse(
+ ::fidl::DecodedMessage<GetCurrentSuspendReasonResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCurrentSuspendReasonResponse::PrimarySize,
+ GetCurrentSuspendReasonResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetCurrentSuspendReasonCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint8_t cur_suspend_reason) {
+ TestDevice_GetCurrentSuspendReason_Response response;
+ response.cur_suspend_reason = std::move(cur_suspend_reason);
+
+ Reply(std::move(_buffer), TestDevice_GetCurrentSuspendReason_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::GetCurrentSuspendReasonCompleterBase::Reply(::fidl::DecodedMessage<GetCurrentSuspendReasonResponse> params) {
+ TestDevice::SetTransactionHeaderFor::GetCurrentSuspendReasonResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::GetCurrentDevicePerformanceStateCompleterBase::Reply(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCurrentDevicePerformanceStateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetCurrentDevicePerformanceStateResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetCurrentDevicePerformanceStateResponse(
+ ::fidl::DecodedMessage<GetCurrentDevicePerformanceStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCurrentDevicePerformanceStateResponse::PrimarySize,
+ GetCurrentDevicePerformanceStateResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetCurrentDevicePerformanceStateCompleterBase::ReplySuccess(int32_t cur_state) {
+ TestDevice_GetCurrentDevicePerformanceState_Response response;
+ response.cur_state = std::move(cur_state);
+
+ Reply(TestDevice_GetCurrentDevicePerformanceState_Result::WithResponse(&response));
+}
+void TestDevice::Interface::GetCurrentDevicePerformanceStateCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_GetCurrentDevicePerformanceState_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::GetCurrentDevicePerformanceStateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Result result) {
+ if (_buffer.capacity() < GetCurrentDevicePerformanceStateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetCurrentDevicePerformanceStateResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetCurrentDevicePerformanceStateResponse(
+ ::fidl::DecodedMessage<GetCurrentDevicePerformanceStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCurrentDevicePerformanceStateResponse::PrimarySize,
+ GetCurrentDevicePerformanceStateResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetCurrentDevicePerformanceStateCompleterBase::ReplySuccess(::fidl::BytePart _buffer, int32_t cur_state) {
+ TestDevice_GetCurrentDevicePerformanceState_Response response;
+ response.cur_state = std::move(cur_state);
+
+ Reply(std::move(_buffer), TestDevice_GetCurrentDevicePerformanceState_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::GetCurrentDevicePerformanceStateCompleterBase::Reply(::fidl::DecodedMessage<GetCurrentDevicePerformanceStateResponse> params) {
+ TestDevice::SetTransactionHeaderFor::GetCurrentDevicePerformanceStateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::GetCurrentDeviceAutoSuspendConfigCompleterBase::Reply(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCurrentDeviceAutoSuspendConfigResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetCurrentDeviceAutoSuspendConfigResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetCurrentDeviceAutoSuspendConfigResponse(
+ ::fidl::DecodedMessage<GetCurrentDeviceAutoSuspendConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCurrentDeviceAutoSuspendConfigResponse::PrimarySize,
+ GetCurrentDeviceAutoSuspendConfigResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetCurrentDeviceAutoSuspendConfigCompleterBase::ReplySuccess(bool enabled, ::llcpp::fuchsia::device::DevicePowerState deepest_sleep_state) {
+ TestDevice_GetCurrentDeviceAutoSuspendConfig_Response response;
+ response.enabled = std::move(enabled);
+ response.deepest_sleep_state = std::move(deepest_sleep_state);
+
+ Reply(TestDevice_GetCurrentDeviceAutoSuspendConfig_Result::WithResponse(&response));
+}
+void TestDevice::Interface::GetCurrentDeviceAutoSuspendConfigCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_GetCurrentDeviceAutoSuspendConfig_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::GetCurrentDeviceAutoSuspendConfigCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Result result) {
+ if (_buffer.capacity() < GetCurrentDeviceAutoSuspendConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetCurrentDeviceAutoSuspendConfigResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetCurrentDeviceAutoSuspendConfigResponse(
+ ::fidl::DecodedMessage<GetCurrentDeviceAutoSuspendConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCurrentDeviceAutoSuspendConfigResponse::PrimarySize,
+ GetCurrentDeviceAutoSuspendConfigResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetCurrentDeviceAutoSuspendConfigCompleterBase::ReplySuccess(::fidl::BytePart _buffer, bool enabled, ::llcpp::fuchsia::device::DevicePowerState deepest_sleep_state) {
+ TestDevice_GetCurrentDeviceAutoSuspendConfig_Response response;
+ response.enabled = std::move(enabled);
+ response.deepest_sleep_state = std::move(deepest_sleep_state);
+
+ Reply(std::move(_buffer), TestDevice_GetCurrentDeviceAutoSuspendConfig_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::GetCurrentDeviceAutoSuspendConfigCompleterBase::Reply(::fidl::DecodedMessage<GetCurrentDeviceAutoSuspendConfigResponse> params) {
+ TestDevice::SetTransactionHeaderFor::GetCurrentDeviceAutoSuspendConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void TestDevice::SetTransactionHeaderFor::AddDeviceWithPowerArgsRequest(const ::fidl::DecodedMessage<TestDevice::AddDeviceWithPowerArgsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_AddDeviceWithPowerArgs_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::AddDeviceWithPowerArgsResponse(const ::fidl::DecodedMessage<TestDevice::AddDeviceWithPowerArgsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_AddDeviceWithPowerArgs_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::GetCurrentDevicePowerStateRequest(const ::fidl::DecodedMessage<TestDevice::GetCurrentDevicePowerStateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetCurrentDevicePowerState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::GetCurrentDevicePowerStateResponse(const ::fidl::DecodedMessage<TestDevice::GetCurrentDevicePowerStateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetCurrentDevicePowerState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::GetCurrentSuspendReasonRequest(const ::fidl::DecodedMessage<TestDevice::GetCurrentSuspendReasonRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetCurrentSuspendReason_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::GetCurrentSuspendReasonResponse(const ::fidl::DecodedMessage<TestDevice::GetCurrentSuspendReasonResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetCurrentSuspendReason_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::GetCurrentDevicePerformanceStateRequest(const ::fidl::DecodedMessage<TestDevice::GetCurrentDevicePerformanceStateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetCurrentDevicePerformanceState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::GetCurrentDevicePerformanceStateResponse(const ::fidl::DecodedMessage<TestDevice::GetCurrentDevicePerformanceStateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetCurrentDevicePerformanceState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::GetCurrentDeviceAutoSuspendConfigRequest(const ::fidl::DecodedMessage<TestDevice::GetCurrentDeviceAutoSuspendConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetCurrentDeviceAutoSuspendConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::GetCurrentDeviceAutoSuspendConfigResponse(const ::fidl::DecodedMessage<TestDevice::GetCurrentDeviceAutoSuspendConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetCurrentDeviceAutoSuspendConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace test
+} // namespace power
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/dev/test/ddk-power/gen/llcpp/include/fuchsia/device/power/test/llcpp/fidl.h b/zircon/system/dev/test/ddk-power/gen/llcpp/include/fuchsia/device/power/test/llcpp/fidl.h
new file mode 100644
index 0000000..398039d
--- /dev/null
+++ b/zircon/system/dev/test/ddk-power/gen/llcpp/include/fuchsia/device/power/test/llcpp/fidl.h
@@ -0,0 +1,1200 @@
+// 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 <zircon/fidl.h>
+
+#include <fuchsia/device/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace power {
+namespace test {
+
+struct TestDevice_GetCurrentDevicePowerState_Response;
+struct TestDevice_GetCurrentDevicePowerState_Result;
+struct TestDevice_GetCurrentDeviceAutoSuspendConfig_Response;
+struct TestDevice_GetCurrentDeviceAutoSuspendConfig_Result;
+struct TestDevice_GetCurrentSuspendReason_Response;
+struct TestDevice_GetCurrentSuspendReason_Result;
+struct TestDevice_GetCurrentDevicePerformanceState_Response;
+struct TestDevice_GetCurrentDevicePerformanceState_Result;
+struct TestDevice_AddDeviceWithPowerArgs_Response;
+struct TestDevice_AddDeviceWithPowerArgs_Result;
+class TestDevice;
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_GetCurrentDevicePowerState_ResultTable;
+
+struct TestDevice_GetCurrentDevicePowerState_Result {
+ TestDevice_GetCurrentDevicePowerState_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_GetCurrentDevicePowerState_Result WithResponse(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response* val) {
+ TestDevice_GetCurrentDevicePowerState_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_GetCurrentDevicePowerState_Result WithErr(int32_t* val) {
+ TestDevice_GetCurrentDevicePowerState_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_GetCurrentDevicePowerState_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_GetCurrentDeviceAutoSuspendConfig_ResultTable;
+
+struct TestDevice_GetCurrentDeviceAutoSuspendConfig_Result {
+ TestDevice_GetCurrentDeviceAutoSuspendConfig_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_GetCurrentDeviceAutoSuspendConfig_Result WithResponse(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response* val) {
+ TestDevice_GetCurrentDeviceAutoSuspendConfig_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_GetCurrentDeviceAutoSuspendConfig_Result WithErr(int32_t* val) {
+ TestDevice_GetCurrentDeviceAutoSuspendConfig_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_GetCurrentDeviceAutoSuspendConfig_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_GetCurrentSuspendReason_ResultTable;
+
+struct TestDevice_GetCurrentSuspendReason_Result {
+ TestDevice_GetCurrentSuspendReason_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_GetCurrentSuspendReason_Result WithResponse(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response* val) {
+ TestDevice_GetCurrentSuspendReason_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_GetCurrentSuspendReason_Result WithErr(int32_t* val) {
+ TestDevice_GetCurrentSuspendReason_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_GetCurrentSuspendReason_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_GetCurrentDevicePerformanceState_ResultTable;
+
+struct TestDevice_GetCurrentDevicePerformanceState_Result {
+ TestDevice_GetCurrentDevicePerformanceState_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_GetCurrentDevicePerformanceState_Result WithResponse(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response* val) {
+ TestDevice_GetCurrentDevicePerformanceState_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_GetCurrentDevicePerformanceState_Result WithErr(int32_t* val) {
+ TestDevice_GetCurrentDevicePerformanceState_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_GetCurrentDevicePerformanceState_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_AddDeviceWithPowerArgs_ResultTable;
+
+struct TestDevice_AddDeviceWithPowerArgs_Result {
+ TestDevice_AddDeviceWithPowerArgs_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_AddDeviceWithPowerArgs_Result WithResponse(::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response* val) {
+ TestDevice_AddDeviceWithPowerArgs_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_AddDeviceWithPowerArgs_Result WithErr(int32_t* val) {
+ TestDevice_AddDeviceWithPowerArgs_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_AddDeviceWithPowerArgs_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_GetCurrentDevicePowerState_ResponseTable;
+
+struct TestDevice_GetCurrentDevicePowerState_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_GetCurrentDevicePowerState_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::device::DevicePowerState cur_state = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_GetCurrentDeviceAutoSuspendConfig_ResponseTable;
+
+struct TestDevice_GetCurrentDeviceAutoSuspendConfig_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_GetCurrentDeviceAutoSuspendConfig_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 2;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ bool enabled = {};
+
+ ::llcpp::fuchsia::device::DevicePowerState deepest_sleep_state = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_GetCurrentSuspendReason_ResponseTable;
+
+struct TestDevice_GetCurrentSuspendReason_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_GetCurrentSuspendReason_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t cur_suspend_reason = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_GetCurrentDevicePerformanceState_ResponseTable;
+
+struct TestDevice_GetCurrentDevicePerformanceState_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_GetCurrentDevicePerformanceState_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ int32_t cur_state = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDevice_AddDeviceWithPowerArgs_ResponseTable;
+
+struct TestDevice_AddDeviceWithPowerArgs_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDevice_AddDeviceWithPowerArgs_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceAddDeviceWithPowerArgsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceAddDeviceWithPowerArgsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePowerStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePowerStateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentSuspendReasonRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentSuspendReasonResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePerformanceStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePerformanceStateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDeviceAutoSuspendConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_power_test_TestDeviceGetCurrentDeviceAutoSuspendConfigResponseTable;
+
+class TestDevice final {
+ TestDevice() = delete;
+ public:
+
+ struct AddDeviceWithPowerArgsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDeviceAddDeviceWithPowerArgsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AddDeviceWithPowerArgsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info;
+ ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info;
+ bool make_visible;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDeviceAddDeviceWithPowerArgsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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 = AddDeviceWithPowerArgsResponse;
+ };
+
+ struct GetCurrentDevicePowerStateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePowerStateResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetCurrentDevicePowerStateRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetCurrentSuspendReasonResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDeviceGetCurrentSuspendReasonResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetCurrentSuspendReasonRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetCurrentDevicePerformanceStateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDeviceGetCurrentDevicePerformanceStateResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetCurrentDevicePerformanceStateRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetCurrentDeviceAutoSuspendConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_power_test_TestDeviceGetCurrentDeviceAutoSuspendConfigResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetCurrentDeviceAutoSuspendConfigRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class AddDeviceWithPowerArgs_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AddDeviceWithPowerArgs_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible);
+ ~AddDeviceWithPowerArgs_Impl() = default;
+ AddDeviceWithPowerArgs_Impl(AddDeviceWithPowerArgs_Impl&& other) = default;
+ AddDeviceWithPowerArgs_Impl& operator=(AddDeviceWithPowerArgs_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 GetCurrentDevicePowerState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetCurrentDevicePowerState_Impl(::zx::unowned_channel _client_end);
+ ~GetCurrentDevicePowerState_Impl() = default;
+ GetCurrentDevicePowerState_Impl(GetCurrentDevicePowerState_Impl&& other) = default;
+ GetCurrentDevicePowerState_Impl& operator=(GetCurrentDevicePowerState_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 GetCurrentSuspendReason_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetCurrentSuspendReason_Impl(::zx::unowned_channel _client_end);
+ ~GetCurrentSuspendReason_Impl() = default;
+ GetCurrentSuspendReason_Impl(GetCurrentSuspendReason_Impl&& other) = default;
+ GetCurrentSuspendReason_Impl& operator=(GetCurrentSuspendReason_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 GetCurrentDevicePerformanceState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetCurrentDevicePerformanceState_Impl(::zx::unowned_channel _client_end);
+ ~GetCurrentDevicePerformanceState_Impl() = default;
+ GetCurrentDevicePerformanceState_Impl(GetCurrentDevicePerformanceState_Impl&& other) = default;
+ GetCurrentDevicePerformanceState_Impl& operator=(GetCurrentDevicePerformanceState_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 GetCurrentDeviceAutoSuspendConfig_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetCurrentDeviceAutoSuspendConfig_Impl(::zx::unowned_channel _client_end);
+ ~GetCurrentDeviceAutoSuspendConfig_Impl() = default;
+ GetCurrentDeviceAutoSuspendConfig_Impl(GetCurrentDeviceAutoSuspendConfig_Impl&& other) = default;
+ GetCurrentDeviceAutoSuspendConfig_Impl& operator=(GetCurrentDeviceAutoSuspendConfig_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 AddDeviceWithPowerArgs = AddDeviceWithPowerArgs_Impl<AddDeviceWithPowerArgsResponse>;
+ using GetCurrentDevicePowerState = GetCurrentDevicePowerState_Impl<GetCurrentDevicePowerStateResponse>;
+ using GetCurrentSuspendReason = GetCurrentSuspendReason_Impl<GetCurrentSuspendReasonResponse>;
+ using GetCurrentDevicePerformanceState = GetCurrentDevicePerformanceState_Impl<GetCurrentDevicePerformanceStateResponse>;
+ using GetCurrentDeviceAutoSuspendConfig = GetCurrentDeviceAutoSuspendConfig_Impl<GetCurrentDeviceAutoSuspendConfigResponse>;
+ };
+
+ // 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 AddDeviceWithPowerArgs_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AddDeviceWithPowerArgs_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible, ::fidl::BytePart _response_buffer);
+ ~AddDeviceWithPowerArgs_Impl() = default;
+ AddDeviceWithPowerArgs_Impl(AddDeviceWithPowerArgs_Impl&& other) = default;
+ AddDeviceWithPowerArgs_Impl& operator=(AddDeviceWithPowerArgs_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 GetCurrentDevicePowerState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetCurrentDevicePowerState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetCurrentDevicePowerState_Impl() = default;
+ GetCurrentDevicePowerState_Impl(GetCurrentDevicePowerState_Impl&& other) = default;
+ GetCurrentDevicePowerState_Impl& operator=(GetCurrentDevicePowerState_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 GetCurrentSuspendReason_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetCurrentSuspendReason_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetCurrentSuspendReason_Impl() = default;
+ GetCurrentSuspendReason_Impl(GetCurrentSuspendReason_Impl&& other) = default;
+ GetCurrentSuspendReason_Impl& operator=(GetCurrentSuspendReason_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 GetCurrentDevicePerformanceState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetCurrentDevicePerformanceState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetCurrentDevicePerformanceState_Impl() = default;
+ GetCurrentDevicePerformanceState_Impl(GetCurrentDevicePerformanceState_Impl&& other) = default;
+ GetCurrentDevicePerformanceState_Impl& operator=(GetCurrentDevicePerformanceState_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 GetCurrentDeviceAutoSuspendConfig_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetCurrentDeviceAutoSuspendConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetCurrentDeviceAutoSuspendConfig_Impl() = default;
+ GetCurrentDeviceAutoSuspendConfig_Impl(GetCurrentDeviceAutoSuspendConfig_Impl&& other) = default;
+ GetCurrentDeviceAutoSuspendConfig_Impl& operator=(GetCurrentDeviceAutoSuspendConfig_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 AddDeviceWithPowerArgs = AddDeviceWithPowerArgs_Impl<AddDeviceWithPowerArgsResponse>;
+ using GetCurrentDevicePowerState = GetCurrentDevicePowerState_Impl<GetCurrentDevicePowerStateResponse>;
+ using GetCurrentSuspendReason = GetCurrentSuspendReason_Impl<GetCurrentSuspendReasonResponse>;
+ using GetCurrentDevicePerformanceState = GetCurrentDevicePerformanceState_Impl<GetCurrentDevicePerformanceStateResponse>;
+ using GetCurrentDeviceAutoSuspendConfig = GetCurrentDeviceAutoSuspendConfig_Impl<GetCurrentDeviceAutoSuspendConfigResponse>;
+ };
+
+ 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_; }
+
+ // Add Test Device with some powerargs
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::AddDeviceWithPowerArgs AddDeviceWithPowerArgs(::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible);
+
+ // Add Test Device with some powerargs
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddDeviceWithPowerArgs AddDeviceWithPowerArgs(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible, ::fidl::BytePart _response_buffer);
+
+ // Get current power state of the device
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetCurrentDevicePowerState GetCurrentDevicePowerState();
+
+ // Get current power state of the device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetCurrentDevicePowerState GetCurrentDevicePowerState(::fidl::BytePart _response_buffer);
+
+ // Get the suspend reason of the last suspend call
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetCurrentSuspendReason GetCurrentSuspendReason();
+
+ // Get the suspend reason of the last suspend call
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetCurrentSuspendReason GetCurrentSuspendReason(::fidl::BytePart _response_buffer);
+
+ // Get current performance state of the device
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetCurrentDevicePerformanceState GetCurrentDevicePerformanceState();
+
+ // Get current performance state of the device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetCurrentDevicePerformanceState GetCurrentDevicePerformanceState(::fidl::BytePart _response_buffer);
+
+ // Get current auto suspend status and deepest_sleep_state
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetCurrentDeviceAutoSuspendConfig GetCurrentDeviceAutoSuspendConfig();
+
+ // Get current auto suspend status and deepest_sleep_state
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetCurrentDeviceAutoSuspendConfig GetCurrentDeviceAutoSuspendConfig(::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:
+
+ // Add Test Device with some powerargs
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::AddDeviceWithPowerArgs AddDeviceWithPowerArgs(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible);
+
+ // Add Test Device with some powerargs
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddDeviceWithPowerArgs AddDeviceWithPowerArgs(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible, ::fidl::BytePart _response_buffer);
+
+ // Get current power state of the device
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetCurrentDevicePowerState GetCurrentDevicePowerState(::zx::unowned_channel _client_end);
+
+ // Get current power state of the device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetCurrentDevicePowerState GetCurrentDevicePowerState(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get the suspend reason of the last suspend call
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetCurrentSuspendReason GetCurrentSuspendReason(::zx::unowned_channel _client_end);
+
+ // Get the suspend reason of the last suspend call
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetCurrentSuspendReason GetCurrentSuspendReason(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get current performance state of the device
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetCurrentDevicePerformanceState GetCurrentDevicePerformanceState(::zx::unowned_channel _client_end);
+
+ // Get current performance state of the device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetCurrentDevicePerformanceState GetCurrentDevicePerformanceState(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get current auto suspend status and deepest_sleep_state
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetCurrentDeviceAutoSuspendConfig GetCurrentDeviceAutoSuspendConfig(::zx::unowned_channel _client_end);
+
+ // Get current auto suspend status and deepest_sleep_state
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetCurrentDeviceAutoSuspendConfig GetCurrentDeviceAutoSuspendConfig(::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:
+
+ // Add Test Device with some powerargs
+ static ::fidl::DecodeResult<AddDeviceWithPowerArgsResponse> AddDeviceWithPowerArgs(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceWithPowerArgsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Get current power state of the device
+ static ::fidl::DecodeResult<GetCurrentDevicePowerStateResponse> GetCurrentDevicePowerState(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get the suspend reason of the last suspend call
+ static ::fidl::DecodeResult<GetCurrentSuspendReasonResponse> GetCurrentSuspendReason(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get current performance state of the device
+ static ::fidl::DecodeResult<GetCurrentDevicePerformanceStateResponse> GetCurrentDevicePerformanceState(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get current auto suspend status and deepest_sleep_state
+ static ::fidl::DecodeResult<GetCurrentDeviceAutoSuspendConfigResponse> GetCurrentDeviceAutoSuspendConfig(::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 = TestDevice;
+ using _Base = ::fidl::CompleterBase;
+
+ class AddDeviceWithPowerArgsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<AddDeviceWithPowerArgsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AddDeviceWithPowerArgsCompleter = ::fidl::Completer<AddDeviceWithPowerArgsCompleterBase>;
+
+ virtual void AddDeviceWithPowerArgs(::fidl::VectorView<::llcpp::fuchsia::device::DevicePowerStateInfo> info, ::fidl::VectorView<::llcpp::fuchsia::device::DevicePerformanceStateInfo> perf_state_info, bool make_visible, AddDeviceWithPowerArgsCompleter::Sync _completer) = 0;
+
+ class GetCurrentDevicePowerStateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Result result);
+ void ReplySuccess(::llcpp::fuchsia::device::DevicePowerState cur_state);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::DevicePowerState cur_state);
+ void Reply(::fidl::DecodedMessage<GetCurrentDevicePowerStateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCurrentDevicePowerStateCompleter = ::fidl::Completer<GetCurrentDevicePowerStateCompleterBase>;
+
+ virtual void GetCurrentDevicePowerState(GetCurrentDevicePowerStateCompleter::Sync _completer) = 0;
+
+ class GetCurrentSuspendReasonCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Result result);
+ void ReplySuccess(uint8_t cur_suspend_reason);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint8_t cur_suspend_reason);
+ void Reply(::fidl::DecodedMessage<GetCurrentSuspendReasonResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCurrentSuspendReasonCompleter = ::fidl::Completer<GetCurrentSuspendReasonCompleterBase>;
+
+ virtual void GetCurrentSuspendReason(GetCurrentSuspendReasonCompleter::Sync _completer) = 0;
+
+ class GetCurrentDevicePerformanceStateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Result result);
+ void ReplySuccess(int32_t cur_state);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, int32_t cur_state);
+ void Reply(::fidl::DecodedMessage<GetCurrentDevicePerformanceStateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCurrentDevicePerformanceStateCompleter = ::fidl::Completer<GetCurrentDevicePerformanceStateCompleterBase>;
+
+ virtual void GetCurrentDevicePerformanceState(GetCurrentDevicePerformanceStateCompleter::Sync _completer) = 0;
+
+ class GetCurrentDeviceAutoSuspendConfigCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Result result);
+ void ReplySuccess(bool enabled, ::llcpp::fuchsia::device::DevicePowerState deepest_sleep_state);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, bool enabled, ::llcpp::fuchsia::device::DevicePowerState deepest_sleep_state);
+ void Reply(::fidl::DecodedMessage<GetCurrentDeviceAutoSuspendConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCurrentDeviceAutoSuspendConfigCompleter = ::fidl::Completer<GetCurrentDeviceAutoSuspendConfigCompleterBase>;
+
+ virtual void GetCurrentDeviceAutoSuspendConfig(GetCurrentDeviceAutoSuspendConfigCompleter::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 AddDeviceWithPowerArgsRequest(const ::fidl::DecodedMessage<TestDevice::AddDeviceWithPowerArgsRequest>& _msg);
+ static void AddDeviceWithPowerArgsResponse(const ::fidl::DecodedMessage<TestDevice::AddDeviceWithPowerArgsResponse>& _msg);
+ static void GetCurrentDevicePowerStateRequest(const ::fidl::DecodedMessage<TestDevice::GetCurrentDevicePowerStateRequest>& _msg);
+ static void GetCurrentDevicePowerStateResponse(const ::fidl::DecodedMessage<TestDevice::GetCurrentDevicePowerStateResponse>& _msg);
+ static void GetCurrentSuspendReasonRequest(const ::fidl::DecodedMessage<TestDevice::GetCurrentSuspendReasonRequest>& _msg);
+ static void GetCurrentSuspendReasonResponse(const ::fidl::DecodedMessage<TestDevice::GetCurrentSuspendReasonResponse>& _msg);
+ static void GetCurrentDevicePerformanceStateRequest(const ::fidl::DecodedMessage<TestDevice::GetCurrentDevicePerformanceStateRequest>& _msg);
+ static void GetCurrentDevicePerformanceStateResponse(const ::fidl::DecodedMessage<TestDevice::GetCurrentDevicePerformanceStateResponse>& _msg);
+ static void GetCurrentDeviceAutoSuspendConfigRequest(const ::fidl::DecodedMessage<TestDevice::GetCurrentDeviceAutoSuspendConfigRequest>& _msg);
+ static void GetCurrentDeviceAutoSuspendConfigResponse(const ::fidl::DecodedMessage<TestDevice::GetCurrentDeviceAutoSuspendConfigResponse>& _msg);
+ };
+};
+
+} // namespace test
+} // namespace power
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response, cur_state) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response) == ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePowerState_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response, enabled) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response, deepest_sleep_state) == 1);
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response) == ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDeviceAutoSuspendConfig_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response, cur_suspend_reason) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response) == ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentSuspendReason_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response, cur_state) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response) == ::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_GetCurrentDevicePerformanceState_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response) == ::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::power::test::TestDevice_AddDeviceWithPowerArgs_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsRequest)
+ == ::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsRequest, info) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsRequest, perf_state_info) == 32);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsRequest, make_visible) == 48);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsResponse)
+ == ::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice::AddDeviceWithPowerArgsResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePowerStateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePowerStateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePowerStateResponse)
+ == ::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePowerStateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePowerStateResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentSuspendReasonResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentSuspendReasonResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentSuspendReasonResponse)
+ == ::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentSuspendReasonResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentSuspendReasonResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePerformanceStateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePerformanceStateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePerformanceStateResponse)
+ == ::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePerformanceStateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDevicePerformanceStateResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDeviceAutoSuspendConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDeviceAutoSuspendConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDeviceAutoSuspendConfigResponse)
+ == ::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDeviceAutoSuspendConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::power::test::TestDevice::GetCurrentDeviceAutoSuspendConfigResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/dev/test/ddk-schedule-work/gen/llcpp/fidl.cc b/zircon/system/dev/test/ddk-schedule-work/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..80ad3ab
--- /dev/null
+++ b/zircon/system/dev/test/ddk-schedule-work/gen/llcpp/fidl.cc
@@ -0,0 +1,989 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/device/schedule/work/test/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace schedule {
+namespace work {
+namespace test {
+
+void ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_ScheduleWork_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_ScheduleWork_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_ScheduleWork_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_ScheduleWorkDifferentThread_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_ScheduleWorkDifferentThread_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_ScheduleWorkDifferentThread_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_GetDoneEvent_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_GetDoneEvent_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_GetDoneEvent_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_GetChannel_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_GetChannel_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_GetChannel_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_ScheduleWork_Ordinal = 0x4be6132300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_ScheduleWork_GenOrdinal = 0x170d21d7a7c60c39lu;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_ScheduleWorkDifferentThread_Ordinal = 0x6ab14d600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_ScheduleWorkDifferentThread_GenOrdinal = 0x5f561520dc24b81flu;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkDifferentThreadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkDifferentThreadResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetDoneEvent_Ordinal = 0x2f1b0e5800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetDoneEvent_GenOrdinal = 0x6c1ddc133dc96d1lu;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceGetDoneEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceGetDoneEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_ScheduledWorkRan_Ordinal = 0x686e4e5500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_ScheduledWorkRan_GenOrdinal = 0x1d1b1aabae000a2dlu;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduledWorkRanRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduledWorkRanResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetChannel_Ordinal = 0x1828922200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_GetChannel_GenOrdinal = 0x3097d0cfd3d89a66lu;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceGetChannelResponseTable;
+
+} // namespace
+template <>
+TestDevice::ResultOf::ScheduleWork_Impl<TestDevice::ScheduleWorkResponse>::ScheduleWork_Impl(::zx::unowned_channel _client_end, uint32_t batch_size, uint32_t num_work_items) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleWorkRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ScheduleWorkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ScheduleWorkRequest*>(_write_bytes);
+ _request.batch_size = std::move(batch_size);
+ _request.num_work_items = std::move(num_work_items);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduleWorkRequest));
+ ::fidl::DecodedMessage<ScheduleWorkRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::ScheduleWork(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::ScheduleWork TestDevice::SyncClient::ScheduleWork(uint32_t batch_size, uint32_t num_work_items) {
+ return ResultOf::ScheduleWork(::zx::unowned_channel(this->channel_), std::move(batch_size), std::move(num_work_items));
+}
+
+TestDevice::ResultOf::ScheduleWork TestDevice::Call::ScheduleWork(::zx::unowned_channel _client_end, uint32_t batch_size, uint32_t num_work_items) {
+ return ResultOf::ScheduleWork(std::move(_client_end), std::move(batch_size), std::move(num_work_items));
+}
+
+template <>
+TestDevice::UnownedResultOf::ScheduleWork_Impl<TestDevice::ScheduleWorkResponse>::ScheduleWork_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ScheduleWorkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ScheduleWorkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ScheduleWorkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ScheduleWorkRequest*>(_request_buffer.data());
+ _request.batch_size = std::move(batch_size);
+ _request.num_work_items = std::move(num_work_items);
+ _request_buffer.set_actual(sizeof(ScheduleWorkRequest));
+ ::fidl::DecodedMessage<ScheduleWorkRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::ScheduleWork(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::ScheduleWork TestDevice::SyncClient::ScheduleWork(::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduleWork(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(batch_size), std::move(num_work_items), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::ScheduleWork TestDevice::Call::ScheduleWork(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduleWork(std::move(_client_end), std::move(_request_buffer), std::move(batch_size), std::move(num_work_items), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::ScheduleWorkResponse> TestDevice::InPlace::ScheduleWork(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ScheduleWorkRequest> params, ::fidl::BytePart response_buffer) {
+ TestDevice::SetTransactionHeaderFor::ScheduleWorkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::ScheduleWorkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ScheduleWorkRequest, ScheduleWorkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::ScheduleWorkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::ScheduleWorkDifferentThread_Impl<TestDevice::ScheduleWorkDifferentThreadResponse>::ScheduleWorkDifferentThread_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleWorkDifferentThreadRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ScheduleWorkDifferentThreadRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduleWorkDifferentThreadRequest));
+ ::fidl::DecodedMessage<ScheduleWorkDifferentThreadRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::ScheduleWorkDifferentThread(std::move(_client_end), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::ScheduleWorkDifferentThread TestDevice::SyncClient::ScheduleWorkDifferentThread() {
+ return ResultOf::ScheduleWorkDifferentThread(::zx::unowned_channel(this->channel_));
+}
+
+TestDevice::ResultOf::ScheduleWorkDifferentThread TestDevice::Call::ScheduleWorkDifferentThread(::zx::unowned_channel _client_end) {
+ return ResultOf::ScheduleWorkDifferentThread(std::move(_client_end));
+}
+
+template <>
+TestDevice::UnownedResultOf::ScheduleWorkDifferentThread_Impl<TestDevice::ScheduleWorkDifferentThreadResponse>::ScheduleWorkDifferentThread_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ScheduleWorkDifferentThreadRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ScheduleWorkDifferentThreadRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ScheduleWorkDifferentThreadRequest));
+ ::fidl::DecodedMessage<ScheduleWorkDifferentThreadRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::ScheduleWorkDifferentThread(std::move(_client_end), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::ScheduleWorkDifferentThread TestDevice::SyncClient::ScheduleWorkDifferentThread(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduleWorkDifferentThread(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::ScheduleWorkDifferentThread TestDevice::Call::ScheduleWorkDifferentThread(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduleWorkDifferentThread(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::ScheduleWorkDifferentThreadResponse> TestDevice::InPlace::ScheduleWorkDifferentThread(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ScheduleWorkDifferentThreadRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ScheduleWorkDifferentThreadRequest> params(std::move(_request_buffer));
+ TestDevice::SetTransactionHeaderFor::ScheduleWorkDifferentThreadRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::ScheduleWorkDifferentThreadResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ScheduleWorkDifferentThreadRequest, ScheduleWorkDifferentThreadResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::ScheduleWorkDifferentThreadResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::GetDoneEvent_Impl<TestDevice::GetDoneEventResponse>::GetDoneEvent_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDoneEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDoneEventRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDoneEventRequest));
+ ::fidl::DecodedMessage<GetDoneEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::GetDoneEvent(std::move(_client_end), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::GetDoneEvent TestDevice::SyncClient::GetDoneEvent() {
+ return ResultOf::GetDoneEvent(::zx::unowned_channel(this->channel_));
+}
+
+TestDevice::ResultOf::GetDoneEvent TestDevice::Call::GetDoneEvent(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDoneEvent(std::move(_client_end));
+}
+
+template <>
+TestDevice::UnownedResultOf::GetDoneEvent_Impl<TestDevice::GetDoneEventResponse>::GetDoneEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDoneEventRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDoneEventRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDoneEventRequest));
+ ::fidl::DecodedMessage<GetDoneEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::GetDoneEvent(std::move(_client_end), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::GetDoneEvent TestDevice::SyncClient::GetDoneEvent(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDoneEvent(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::GetDoneEvent TestDevice::Call::GetDoneEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDoneEvent(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::GetDoneEventResponse> TestDevice::InPlace::GetDoneEvent(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDoneEventRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDoneEventRequest> params(std::move(_request_buffer));
+ TestDevice::SetTransactionHeaderFor::GetDoneEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetDoneEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDoneEventRequest, GetDoneEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetDoneEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::ScheduledWorkRan_Impl<TestDevice::ScheduledWorkRanResponse>::ScheduledWorkRan_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduledWorkRanRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ScheduledWorkRanRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduledWorkRanRequest));
+ ::fidl::DecodedMessage<ScheduledWorkRanRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::ScheduledWorkRan(std::move(_client_end), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::ScheduledWorkRan TestDevice::SyncClient::ScheduledWorkRan() {
+ return ResultOf::ScheduledWorkRan(::zx::unowned_channel(this->channel_));
+}
+
+TestDevice::ResultOf::ScheduledWorkRan TestDevice::Call::ScheduledWorkRan(::zx::unowned_channel _client_end) {
+ return ResultOf::ScheduledWorkRan(std::move(_client_end));
+}
+
+template <>
+TestDevice::UnownedResultOf::ScheduledWorkRan_Impl<TestDevice::ScheduledWorkRanResponse>::ScheduledWorkRan_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ScheduledWorkRanRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ScheduledWorkRanRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ScheduledWorkRanRequest));
+ ::fidl::DecodedMessage<ScheduledWorkRanRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::ScheduledWorkRan(std::move(_client_end), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::ScheduledWorkRan TestDevice::SyncClient::ScheduledWorkRan(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduledWorkRan(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::ScheduledWorkRan TestDevice::Call::ScheduledWorkRan(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduledWorkRan(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::ScheduledWorkRanResponse> TestDevice::InPlace::ScheduledWorkRan(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ScheduledWorkRanRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ScheduledWorkRanRequest> params(std::move(_request_buffer));
+ TestDevice::SetTransactionHeaderFor::ScheduledWorkRanRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::ScheduledWorkRanResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ScheduledWorkRanRequest, ScheduledWorkRanResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::ScheduledWorkRanResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+TestDevice::ResultOf::GetChannel_Impl<TestDevice::GetChannelResponse>::GetChannel_Impl(::zx::unowned_channel _client_end, ::zx::channel test) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChannelRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetChannelRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetChannelRequest*>(_write_bytes);
+ _request.test = std::move(test);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::GetChannel(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::GetChannel TestDevice::SyncClient::GetChannel(::zx::channel test) {
+ return ResultOf::GetChannel(::zx::unowned_channel(this->channel_), std::move(test));
+}
+
+TestDevice::ResultOf::GetChannel TestDevice::Call::GetChannel(::zx::unowned_channel _client_end, ::zx::channel test) {
+ return ResultOf::GetChannel(std::move(_client_end), std::move(test));
+}
+
+template <>
+TestDevice::UnownedResultOf::GetChannel_Impl<TestDevice::GetChannelResponse>::GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel test, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetChannelRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetChannelResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetChannelRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetChannelRequest*>(_request_buffer.data());
+ _request.test = std::move(test);
+ _request_buffer.set_actual(sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::GetChannel(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::GetChannel TestDevice::SyncClient::GetChannel(::fidl::BytePart _request_buffer, ::zx::channel test, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetChannel(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(test), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::GetChannel TestDevice::Call::GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel test, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetChannel(std::move(_client_end), std::move(_request_buffer), std::move(test), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::GetChannelResponse> TestDevice::InPlace::GetChannel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetChannelRequest> params, ::fidl::BytePart response_buffer) {
+ TestDevice::SetTransactionHeaderFor::GetChannelRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetChannelResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetChannelRequest, GetChannelResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::GetChannelResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool TestDevice::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kTestDevice_ScheduleWork_Ordinal:
+ case kTestDevice_ScheduleWork_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ScheduleWorkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ScheduleWork(std::move(message->batch_size), std::move(message->num_work_items),
+ Interface::ScheduleWorkCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_ScheduleWorkDifferentThread_Ordinal:
+ case kTestDevice_ScheduleWorkDifferentThread_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ScheduleWorkDifferentThreadRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ScheduleWorkDifferentThread(
+ Interface::ScheduleWorkDifferentThreadCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_GetDoneEvent_Ordinal:
+ case kTestDevice_GetDoneEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDoneEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDoneEvent(
+ Interface::GetDoneEventCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_ScheduledWorkRan_Ordinal:
+ case kTestDevice_ScheduledWorkRan_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ScheduledWorkRanRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ScheduledWorkRan(
+ Interface::ScheduledWorkRanCompleter::Sync(txn));
+ return true;
+ }
+ case kTestDevice_GetChannel_Ordinal:
+ case kTestDevice_GetChannel_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetChannelRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetChannel(std::move(message->test),
+ Interface::GetChannelCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool TestDevice::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void TestDevice::Interface::ScheduleWorkCompleterBase::Reply(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleWorkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ScheduleWorkResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::ScheduleWorkResponse(
+ ::fidl::DecodedMessage<ScheduleWorkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduleWorkResponse::PrimarySize,
+ ScheduleWorkResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::ScheduleWorkCompleterBase::ReplySuccess() {
+ TestDevice_ScheduleWork_Response response;
+
+ Reply(TestDevice_ScheduleWork_Result::WithResponse(&response));
+}
+void TestDevice::Interface::ScheduleWorkCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_ScheduleWork_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::ScheduleWorkCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Result result) {
+ if (_buffer.capacity() < ScheduleWorkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ScheduleWorkResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::ScheduleWorkResponse(
+ ::fidl::DecodedMessage<ScheduleWorkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduleWorkResponse::PrimarySize,
+ ScheduleWorkResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::ScheduleWorkCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ TestDevice_ScheduleWork_Response response;
+
+ Reply(std::move(_buffer), TestDevice_ScheduleWork_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::ScheduleWorkCompleterBase::Reply(::fidl::DecodedMessage<ScheduleWorkResponse> params) {
+ TestDevice::SetTransactionHeaderFor::ScheduleWorkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::ScheduleWorkDifferentThreadCompleterBase::Reply(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleWorkDifferentThreadResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ScheduleWorkDifferentThreadResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::ScheduleWorkDifferentThreadResponse(
+ ::fidl::DecodedMessage<ScheduleWorkDifferentThreadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduleWorkDifferentThreadResponse::PrimarySize,
+ ScheduleWorkDifferentThreadResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::ScheduleWorkDifferentThreadCompleterBase::ReplySuccess() {
+ TestDevice_ScheduleWorkDifferentThread_Response response;
+
+ Reply(TestDevice_ScheduleWorkDifferentThread_Result::WithResponse(&response));
+}
+void TestDevice::Interface::ScheduleWorkDifferentThreadCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_ScheduleWorkDifferentThread_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::ScheduleWorkDifferentThreadCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Result result) {
+ if (_buffer.capacity() < ScheduleWorkDifferentThreadResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ScheduleWorkDifferentThreadResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::ScheduleWorkDifferentThreadResponse(
+ ::fidl::DecodedMessage<ScheduleWorkDifferentThreadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduleWorkDifferentThreadResponse::PrimarySize,
+ ScheduleWorkDifferentThreadResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::ScheduleWorkDifferentThreadCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ TestDevice_ScheduleWorkDifferentThread_Response response;
+
+ Reply(std::move(_buffer), TestDevice_ScheduleWorkDifferentThread_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::ScheduleWorkDifferentThreadCompleterBase::Reply(::fidl::DecodedMessage<ScheduleWorkDifferentThreadResponse> params) {
+ TestDevice::SetTransactionHeaderFor::ScheduleWorkDifferentThreadResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::GetDoneEventCompleterBase::Reply(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDoneEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetDoneEventResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetDoneEventResponse(
+ ::fidl::DecodedMessage<GetDoneEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDoneEventResponse::PrimarySize,
+ GetDoneEventResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetDoneEventCompleterBase::ReplySuccess(::zx::event event) {
+ TestDevice_GetDoneEvent_Response response;
+ response.event = std::move(event);
+
+ Reply(TestDevice_GetDoneEvent_Result::WithResponse(&response));
+}
+void TestDevice::Interface::GetDoneEventCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_GetDoneEvent_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::GetDoneEventCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Result result) {
+ if (_buffer.capacity() < GetDoneEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDoneEventResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetDoneEventResponse(
+ ::fidl::DecodedMessage<GetDoneEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDoneEventResponse::PrimarySize,
+ GetDoneEventResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetDoneEventCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::event event) {
+ TestDevice_GetDoneEvent_Response response;
+ response.event = std::move(event);
+
+ Reply(std::move(_buffer), TestDevice_GetDoneEvent_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::GetDoneEventCompleterBase::Reply(::fidl::DecodedMessage<GetDoneEventResponse> params) {
+ TestDevice::SetTransactionHeaderFor::GetDoneEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::ScheduledWorkRanCompleterBase::Reply(uint32_t work_items_run, ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduledWorkRanResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ScheduledWorkRanResponse*>(_write_bytes);
+ TestDevice::SetTransactionHeaderFor::ScheduledWorkRanResponse(
+ ::fidl::DecodedMessage<ScheduledWorkRanResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduledWorkRanResponse::PrimarySize,
+ ScheduledWorkRanResponse::PrimarySize)));
+ _response.work_items_run = std::move(work_items_run);
+ _response.histogram = std::move(histogram);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduledWorkRanResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ScheduledWorkRanResponse>(std::move(_response_bytes)));
+}
+
+void TestDevice::Interface::ScheduledWorkRanCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t work_items_run, ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram) {
+ if (_buffer.capacity() < ScheduledWorkRanResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ScheduledWorkRanResponse*>(_buffer.data());
+ TestDevice::SetTransactionHeaderFor::ScheduledWorkRanResponse(
+ ::fidl::DecodedMessage<ScheduledWorkRanResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduledWorkRanResponse::PrimarySize,
+ ScheduledWorkRanResponse::PrimarySize)));
+ _response.work_items_run = std::move(work_items_run);
+ _response.histogram = std::move(histogram);
+ _buffer.set_actual(sizeof(ScheduledWorkRanResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ScheduledWorkRanResponse>(std::move(_buffer)));
+}
+
+void TestDevice::Interface::ScheduledWorkRanCompleterBase::Reply(::fidl::DecodedMessage<ScheduledWorkRanResponse> params) {
+ TestDevice::SetTransactionHeaderFor::ScheduledWorkRanResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void TestDevice::Interface::GetChannelCompleterBase::Reply(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChannelResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetChannelResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetChannelResponse(
+ ::fidl::DecodedMessage<GetChannelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetChannelResponse::PrimarySize,
+ GetChannelResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetChannelCompleterBase::ReplySuccess() {
+ TestDevice_GetChannel_Response response;
+
+ Reply(TestDevice_GetChannel_Result::WithResponse(&response));
+}
+void TestDevice::Interface::GetChannelCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_GetChannel_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::GetChannelCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Result result) {
+ if (_buffer.capacity() < GetChannelResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetChannelResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::GetChannelResponse(
+ ::fidl::DecodedMessage<GetChannelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetChannelResponse::PrimarySize,
+ GetChannelResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::GetChannelCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ TestDevice_GetChannel_Response response;
+
+ Reply(std::move(_buffer), TestDevice_GetChannel_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::GetChannelCompleterBase::Reply(::fidl::DecodedMessage<GetChannelResponse> params) {
+ TestDevice::SetTransactionHeaderFor::GetChannelResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void TestDevice::SetTransactionHeaderFor::ScheduleWorkRequest(const ::fidl::DecodedMessage<TestDevice::ScheduleWorkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_ScheduleWork_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::ScheduleWorkResponse(const ::fidl::DecodedMessage<TestDevice::ScheduleWorkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_ScheduleWork_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::ScheduleWorkDifferentThreadRequest(const ::fidl::DecodedMessage<TestDevice::ScheduleWorkDifferentThreadRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_ScheduleWorkDifferentThread_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::ScheduleWorkDifferentThreadResponse(const ::fidl::DecodedMessage<TestDevice::ScheduleWorkDifferentThreadResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_ScheduleWorkDifferentThread_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::GetDoneEventRequest(const ::fidl::DecodedMessage<TestDevice::GetDoneEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetDoneEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::GetDoneEventResponse(const ::fidl::DecodedMessage<TestDevice::GetDoneEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetDoneEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::ScheduledWorkRanRequest(const ::fidl::DecodedMessage<TestDevice::ScheduledWorkRanRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_ScheduledWorkRan_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::ScheduledWorkRanResponse(const ::fidl::DecodedMessage<TestDevice::ScheduledWorkRanResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_ScheduledWorkRan_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void TestDevice::SetTransactionHeaderFor::GetChannelRequest(const ::fidl::DecodedMessage<TestDevice::GetChannelRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::GetChannelResponse(const ::fidl::DecodedMessage<TestDevice::GetChannelResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_GetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(OwnedChannelDevice_ScheduleWork_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(OwnedChannelDevice_ScheduleWork_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(OwnedChannelDevice_ScheduleWork_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kOwnedChannelDevice_ScheduleWork_Ordinal = 0x45d160ce00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kOwnedChannelDevice_ScheduleWork_GenOrdinal = 0x68e8de848728c3a4lu;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_OwnedChannelDeviceScheduleWorkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_OwnedChannelDeviceScheduleWorkResponseTable;
+
+} // namespace
+template <>
+OwnedChannelDevice::ResultOf::ScheduleWork_Impl<OwnedChannelDevice::ScheduleWorkResponse>::ScheduleWork_Impl(::zx::unowned_channel _client_end, uint32_t batch_size, uint32_t num_work_items) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleWorkRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ScheduleWorkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ScheduleWorkRequest*>(_write_bytes);
+ _request.batch_size = std::move(batch_size);
+ _request.num_work_items = std::move(num_work_items);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduleWorkRequest));
+ ::fidl::DecodedMessage<ScheduleWorkRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ OwnedChannelDevice::InPlace::ScheduleWork(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+OwnedChannelDevice::ResultOf::ScheduleWork OwnedChannelDevice::SyncClient::ScheduleWork(uint32_t batch_size, uint32_t num_work_items) {
+ return ResultOf::ScheduleWork(::zx::unowned_channel(this->channel_), std::move(batch_size), std::move(num_work_items));
+}
+
+OwnedChannelDevice::ResultOf::ScheduleWork OwnedChannelDevice::Call::ScheduleWork(::zx::unowned_channel _client_end, uint32_t batch_size, uint32_t num_work_items) {
+ return ResultOf::ScheduleWork(std::move(_client_end), std::move(batch_size), std::move(num_work_items));
+}
+
+template <>
+OwnedChannelDevice::UnownedResultOf::ScheduleWork_Impl<OwnedChannelDevice::ScheduleWorkResponse>::ScheduleWork_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ScheduleWorkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ScheduleWorkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ScheduleWorkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ScheduleWorkRequest*>(_request_buffer.data());
+ _request.batch_size = std::move(batch_size);
+ _request.num_work_items = std::move(num_work_items);
+ _request_buffer.set_actual(sizeof(ScheduleWorkRequest));
+ ::fidl::DecodedMessage<ScheduleWorkRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ OwnedChannelDevice::InPlace::ScheduleWork(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+OwnedChannelDevice::UnownedResultOf::ScheduleWork OwnedChannelDevice::SyncClient::ScheduleWork(::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduleWork(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(batch_size), std::move(num_work_items), std::move(_response_buffer));
+}
+
+OwnedChannelDevice::UnownedResultOf::ScheduleWork OwnedChannelDevice::Call::ScheduleWork(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduleWork(std::move(_client_end), std::move(_request_buffer), std::move(batch_size), std::move(num_work_items), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<OwnedChannelDevice::ScheduleWorkResponse> OwnedChannelDevice::InPlace::ScheduleWork(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ScheduleWorkRequest> params, ::fidl::BytePart response_buffer) {
+ OwnedChannelDevice::SetTransactionHeaderFor::ScheduleWorkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<OwnedChannelDevice::ScheduleWorkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ScheduleWorkRequest, ScheduleWorkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<OwnedChannelDevice::ScheduleWorkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool OwnedChannelDevice::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kOwnedChannelDevice_ScheduleWork_Ordinal:
+ case kOwnedChannelDevice_ScheduleWork_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ScheduleWorkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ScheduleWork(std::move(message->batch_size), std::move(message->num_work_items),
+ Interface::ScheduleWorkCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool OwnedChannelDevice::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void OwnedChannelDevice::Interface::ScheduleWorkCompleterBase::Reply(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleWorkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ScheduleWorkResponse _response = {};
+ OwnedChannelDevice::SetTransactionHeaderFor::ScheduleWorkResponse(
+ ::fidl::DecodedMessage<ScheduleWorkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduleWorkResponse::PrimarySize,
+ ScheduleWorkResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void OwnedChannelDevice::Interface::ScheduleWorkCompleterBase::ReplySuccess(::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram) {
+ OwnedChannelDevice_ScheduleWork_Response response;
+ response.histogram = std::move(histogram);
+
+ Reply(OwnedChannelDevice_ScheduleWork_Result::WithResponse(&response));
+}
+void OwnedChannelDevice::Interface::ScheduleWorkCompleterBase::ReplyError(int32_t error) {
+ Reply(OwnedChannelDevice_ScheduleWork_Result::WithErr(&error));
+}
+
+void OwnedChannelDevice::Interface::ScheduleWorkCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Result result) {
+ if (_buffer.capacity() < ScheduleWorkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ScheduleWorkResponse _response = {};
+ OwnedChannelDevice::SetTransactionHeaderFor::ScheduleWorkResponse(
+ ::fidl::DecodedMessage<ScheduleWorkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduleWorkResponse::PrimarySize,
+ ScheduleWorkResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void OwnedChannelDevice::Interface::ScheduleWorkCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram) {
+ OwnedChannelDevice_ScheduleWork_Response response;
+ response.histogram = std::move(histogram);
+
+ Reply(std::move(_buffer), OwnedChannelDevice_ScheduleWork_Result::WithResponse(&response));
+}
+
+void OwnedChannelDevice::Interface::ScheduleWorkCompleterBase::Reply(::fidl::DecodedMessage<ScheduleWorkResponse> params) {
+ OwnedChannelDevice::SetTransactionHeaderFor::ScheduleWorkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void OwnedChannelDevice::SetTransactionHeaderFor::ScheduleWorkRequest(const ::fidl::DecodedMessage<OwnedChannelDevice::ScheduleWorkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kOwnedChannelDevice_ScheduleWork_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void OwnedChannelDevice::SetTransactionHeaderFor::ScheduleWorkResponse(const ::fidl::DecodedMessage<OwnedChannelDevice::ScheduleWorkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kOwnedChannelDevice_ScheduleWork_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace test
+} // namespace work
+} // namespace schedule
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/dev/test/ddk-schedule-work/gen/llcpp/include/fuchsia/device/schedule/work/test/llcpp/fidl.h b/zircon/system/dev/test/ddk-schedule-work/gen/llcpp/include/fuchsia/device/schedule/work/test/llcpp/fidl.h
new file mode 100644
index 0000000..f66b84e
--- /dev/null
+++ b/zircon/system/dev/test/ddk-schedule-work/gen/llcpp/include/fuchsia/device/schedule/work/test/llcpp/fidl.h
@@ -0,0 +1,1487 @@
+// 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/event.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace schedule {
+namespace work {
+namespace test {
+
+struct TestDevice_ScheduleWork_Response;
+struct TestDevice_ScheduleWork_Result;
+struct TestDevice_ScheduleWorkDifferentThread_Response;
+struct TestDevice_ScheduleWorkDifferentThread_Result;
+struct TestDevice_GetDoneEvent_Response;
+struct TestDevice_GetDoneEvent_Result;
+struct TestDevice_GetChannel_Response;
+struct TestDevice_GetChannel_Result;
+struct LatencyHistogram;
+class TestDevice;
+struct OwnedChannelDevice_ScheduleWork_Response;
+struct OwnedChannelDevice_ScheduleWork_Result;
+class OwnedChannelDevice;
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDevice_ScheduleWork_ResultTable;
+
+struct TestDevice_ScheduleWork_Result {
+ TestDevice_ScheduleWork_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_ScheduleWork_Result WithResponse(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response* val) {
+ TestDevice_ScheduleWork_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_ScheduleWork_Result WithErr(int32_t* val) {
+ TestDevice_ScheduleWork_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDevice_ScheduleWork_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDevice_ScheduleWorkDifferentThread_ResultTable;
+
+struct TestDevice_ScheduleWorkDifferentThread_Result {
+ TestDevice_ScheduleWorkDifferentThread_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_ScheduleWorkDifferentThread_Result WithResponse(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response* val) {
+ TestDevice_ScheduleWorkDifferentThread_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_ScheduleWorkDifferentThread_Result WithErr(int32_t* val) {
+ TestDevice_ScheduleWorkDifferentThread_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDevice_ScheduleWorkDifferentThread_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDevice_GetDoneEvent_ResultTable;
+
+struct TestDevice_GetDoneEvent_Result {
+ TestDevice_GetDoneEvent_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_GetDoneEvent_Result WithResponse(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response* val) {
+ TestDevice_GetDoneEvent_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_GetDoneEvent_Result WithErr(int32_t* val) {
+ TestDevice_GetDoneEvent_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDevice_GetDoneEvent_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDevice_GetChannel_ResultTable;
+
+struct TestDevice_GetChannel_Result {
+ TestDevice_GetChannel_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_GetChannel_Result WithResponse(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response* val) {
+ TestDevice_GetChannel_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_GetChannel_Result WithErr(int32_t* val) {
+ TestDevice_GetChannel_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDevice_GetChannel_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_OwnedChannelDevice_ScheduleWork_ResultTable;
+
+struct OwnedChannelDevice_ScheduleWork_Result {
+ OwnedChannelDevice_ScheduleWork_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static OwnedChannelDevice_ScheduleWork_Result WithResponse(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response* val) {
+ OwnedChannelDevice_ScheduleWork_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static OwnedChannelDevice_ScheduleWork_Result WithErr(int32_t* val) {
+ OwnedChannelDevice_ScheduleWork_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_OwnedChannelDevice_ScheduleWork_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 80;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDevice_ScheduleWork_ResponseTable;
+
+struct TestDevice_ScheduleWork_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDevice_ScheduleWork_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDevice_ScheduleWorkDifferentThread_ResponseTable;
+
+struct TestDevice_ScheduleWorkDifferentThread_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDevice_ScheduleWorkDifferentThread_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDevice_GetDoneEvent_ResponseTable;
+
+struct TestDevice_GetDoneEvent_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDevice_GetDoneEvent_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::event event = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDevice_GetChannel_ResponseTable;
+
+struct TestDevice_GetChannel_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDevice_GetChannel_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_LatencyHistogramTable;
+
+// Buckets are arranged as following:
+// [0] => [0ns, 100ns]
+// [1] => [100ns, 250ns]
+// [2] => [250ns, 500ns]
+// [3] => [500ns, 1us]
+// [4] => [1us, 2us]
+// [5] => [2us, 4us]
+// [6] => [4us, 7us]
+// [7] => [7us, 15us]
+// [8] => [15us, 30us]
+// [9] => [30us, infinity]
+struct LatencyHistogram {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_LatencyHistogramTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::fidl::Array<uint64_t, 10> buckets = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkDifferentThreadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkDifferentThreadResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceGetDoneEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceGetDoneEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduledWorkRanRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceScheduledWorkRanResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_TestDeviceGetChannelResponseTable;
+
+class TestDevice final {
+ TestDevice() = delete;
+ public:
+
+ struct ScheduleWorkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ScheduleWorkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t batch_size;
+ uint32_t num_work_items;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkRequestTable;
+ 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 = ScheduleWorkResponse;
+ };
+
+ struct ScheduleWorkDifferentThreadResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDeviceScheduleWorkDifferentThreadResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using ScheduleWorkDifferentThreadRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDoneEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDeviceGetDoneEventResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetDoneEventRequest = ::fidl::AnyZeroArgMessage;
+
+ struct ScheduledWorkRanResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t work_items_run;
+ ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDeviceScheduledWorkRanResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 104;
+ 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 ScheduledWorkRanRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetChannelResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDeviceGetChannelResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetChannelRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel test;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_TestDeviceGetChannelRequestTable;
+ 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 = GetChannelResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class ScheduleWork_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ScheduleWork_Impl(::zx::unowned_channel _client_end, uint32_t batch_size, uint32_t num_work_items);
+ ~ScheduleWork_Impl() = default;
+ ScheduleWork_Impl(ScheduleWork_Impl&& other) = default;
+ ScheduleWork_Impl& operator=(ScheduleWork_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 ScheduleWorkDifferentThread_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ScheduleWorkDifferentThread_Impl(::zx::unowned_channel _client_end);
+ ~ScheduleWorkDifferentThread_Impl() = default;
+ ScheduleWorkDifferentThread_Impl(ScheduleWorkDifferentThread_Impl&& other) = default;
+ ScheduleWorkDifferentThread_Impl& operator=(ScheduleWorkDifferentThread_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 GetDoneEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDoneEvent_Impl(::zx::unowned_channel _client_end);
+ ~GetDoneEvent_Impl() = default;
+ GetDoneEvent_Impl(GetDoneEvent_Impl&& other) = default;
+ GetDoneEvent_Impl& operator=(GetDoneEvent_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 ScheduledWorkRan_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ScheduledWorkRan_Impl(::zx::unowned_channel _client_end);
+ ~ScheduledWorkRan_Impl() = default;
+ ScheduledWorkRan_Impl(ScheduledWorkRan_Impl&& other) = default;
+ ScheduledWorkRan_Impl& operator=(ScheduledWorkRan_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 GetChannel_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end, ::zx::channel test);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_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 ScheduleWork = ScheduleWork_Impl<ScheduleWorkResponse>;
+ using ScheduleWorkDifferentThread = ScheduleWorkDifferentThread_Impl<ScheduleWorkDifferentThreadResponse>;
+ using GetDoneEvent = GetDoneEvent_Impl<GetDoneEventResponse>;
+ using ScheduledWorkRan = ScheduledWorkRan_Impl<ScheduledWorkRanResponse>;
+ using GetChannel = GetChannel_Impl<GetChannelResponse>;
+ };
+
+ // 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 ScheduleWork_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ScheduleWork_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer);
+ ~ScheduleWork_Impl() = default;
+ ScheduleWork_Impl(ScheduleWork_Impl&& other) = default;
+ ScheduleWork_Impl& operator=(ScheduleWork_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 ScheduleWorkDifferentThread_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ScheduleWorkDifferentThread_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ScheduleWorkDifferentThread_Impl() = default;
+ ScheduleWorkDifferentThread_Impl(ScheduleWorkDifferentThread_Impl&& other) = default;
+ ScheduleWorkDifferentThread_Impl& operator=(ScheduleWorkDifferentThread_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 GetDoneEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDoneEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDoneEvent_Impl() = default;
+ GetDoneEvent_Impl(GetDoneEvent_Impl&& other) = default;
+ GetDoneEvent_Impl& operator=(GetDoneEvent_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 ScheduledWorkRan_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ScheduledWorkRan_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ScheduledWorkRan_Impl() = default;
+ ScheduledWorkRan_Impl(ScheduledWorkRan_Impl&& other) = default;
+ ScheduledWorkRan_Impl& operator=(ScheduledWorkRan_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 GetChannel_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel test, ::fidl::BytePart _response_buffer);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_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 ScheduleWork = ScheduleWork_Impl<ScheduleWorkResponse>;
+ using ScheduleWorkDifferentThread = ScheduleWorkDifferentThread_Impl<ScheduleWorkDifferentThreadResponse>;
+ using GetDoneEvent = GetDoneEvent_Impl<GetDoneEventResponse>;
+ using ScheduledWorkRan = ScheduledWorkRan_Impl<ScheduledWorkRanResponse>;
+ using GetChannel = GetChannel_Impl<GetChannelResponse>;
+ };
+
+ 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_; }
+
+ // Schedules work. |batch_size| refers to how many work_items to keep
+ // outstanding at any given time, while |num_work_items| refers to total
+ // number of work items.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ScheduleWork ScheduleWork(uint32_t batch_size, uint32_t num_work_items);
+
+ // Schedules work. |batch_size| refers to how many work_items to keep
+ // outstanding at any given time, while |num_work_items| refers to total
+ // number of work items.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ScheduleWork ScheduleWork(::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer);
+
+ // Spawns a thread which schedules work.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ScheduleWorkDifferentThread ScheduleWorkDifferentThread();
+
+ // Spawns a thread which schedules work.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ScheduleWorkDifferentThread ScheduleWorkDifferentThread(::fidl::BytePart _response_buffer);
+
+ // Triggers once all outstanding work is complete.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDoneEvent GetDoneEvent();
+
+ // Triggers once all outstanding work is complete.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDoneEvent GetDoneEvent(::fidl::BytePart _response_buffer);
+
+ // Returns whether how many work items ran since last time it was invoked.
+ // Allocates 120 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ScheduledWorkRan ScheduledWorkRan();
+
+ // Returns whether how many work items ran since last time it was invoked.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ScheduledWorkRan ScheduledWorkRan(::fidl::BytePart _response_buffer);
+
+ // Spawns an thread with a dedicated async loop.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetChannel GetChannel(::zx::channel test);
+
+ // Spawns an thread with a dedicated async loop.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetChannel GetChannel(::fidl::BytePart _request_buffer, ::zx::channel test, ::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:
+
+ // Schedules work. |batch_size| refers to how many work_items to keep
+ // outstanding at any given time, while |num_work_items| refers to total
+ // number of work items.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ScheduleWork ScheduleWork(::zx::unowned_channel _client_end, uint32_t batch_size, uint32_t num_work_items);
+
+ // Schedules work. |batch_size| refers to how many work_items to keep
+ // outstanding at any given time, while |num_work_items| refers to total
+ // number of work items.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ScheduleWork ScheduleWork(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer);
+
+ // Spawns a thread which schedules work.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ScheduleWorkDifferentThread ScheduleWorkDifferentThread(::zx::unowned_channel _client_end);
+
+ // Spawns a thread which schedules work.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ScheduleWorkDifferentThread ScheduleWorkDifferentThread(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Triggers once all outstanding work is complete.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDoneEvent GetDoneEvent(::zx::unowned_channel _client_end);
+
+ // Triggers once all outstanding work is complete.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDoneEvent GetDoneEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns whether how many work items ran since last time it was invoked.
+ // Allocates 120 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ScheduledWorkRan ScheduledWorkRan(::zx::unowned_channel _client_end);
+
+ // Returns whether how many work items ran since last time it was invoked.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ScheduledWorkRan ScheduledWorkRan(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Spawns an thread with a dedicated async loop.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetChannel GetChannel(::zx::unowned_channel _client_end, ::zx::channel test);
+
+ // Spawns an thread with a dedicated async loop.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetChannel GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel test, ::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:
+
+ // Schedules work. |batch_size| refers to how many work_items to keep
+ // outstanding at any given time, while |num_work_items| refers to total
+ // number of work items.
+ static ::fidl::DecodeResult<ScheduleWorkResponse> ScheduleWork(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ScheduleWorkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Spawns a thread which schedules work.
+ static ::fidl::DecodeResult<ScheduleWorkDifferentThreadResponse> ScheduleWorkDifferentThread(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Triggers once all outstanding work is complete.
+ static ::fidl::DecodeResult<GetDoneEventResponse> GetDoneEvent(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns whether how many work items ran since last time it was invoked.
+ static ::fidl::DecodeResult<ScheduledWorkRanResponse> ScheduledWorkRan(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Spawns an thread with a dedicated async loop.
+ static ::fidl::DecodeResult<GetChannelResponse> GetChannel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetChannelRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = TestDevice;
+ using _Base = ::fidl::CompleterBase;
+
+ class ScheduleWorkCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ScheduleWorkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ScheduleWorkCompleter = ::fidl::Completer<ScheduleWorkCompleterBase>;
+
+ virtual void ScheduleWork(uint32_t batch_size, uint32_t num_work_items, ScheduleWorkCompleter::Sync _completer) = 0;
+
+ class ScheduleWorkDifferentThreadCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ScheduleWorkDifferentThreadResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ScheduleWorkDifferentThreadCompleter = ::fidl::Completer<ScheduleWorkDifferentThreadCompleterBase>;
+
+ virtual void ScheduleWorkDifferentThread(ScheduleWorkDifferentThreadCompleter::Sync _completer) = 0;
+
+ class GetDoneEventCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Result result);
+ void ReplySuccess(::zx::event event);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::event event);
+ void Reply(::fidl::DecodedMessage<GetDoneEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDoneEventCompleter = ::fidl::Completer<GetDoneEventCompleterBase>;
+
+ virtual void GetDoneEvent(GetDoneEventCompleter::Sync _completer) = 0;
+
+ class ScheduledWorkRanCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t work_items_run, ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram);
+ void Reply(::fidl::BytePart _buffer, uint32_t work_items_run, ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram);
+ void Reply(::fidl::DecodedMessage<ScheduledWorkRanResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ScheduledWorkRanCompleter = ::fidl::Completer<ScheduledWorkRanCompleterBase>;
+
+ virtual void ScheduledWorkRan(ScheduledWorkRanCompleter::Sync _completer) = 0;
+
+ class GetChannelCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<GetChannelResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetChannelCompleter = ::fidl::Completer<GetChannelCompleterBase>;
+
+ virtual void GetChannel(::zx::channel test, GetChannelCompleter::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 ScheduleWorkRequest(const ::fidl::DecodedMessage<TestDevice::ScheduleWorkRequest>& _msg);
+ static void ScheduleWorkResponse(const ::fidl::DecodedMessage<TestDevice::ScheduleWorkResponse>& _msg);
+ static void ScheduleWorkDifferentThreadRequest(const ::fidl::DecodedMessage<TestDevice::ScheduleWorkDifferentThreadRequest>& _msg);
+ static void ScheduleWorkDifferentThreadResponse(const ::fidl::DecodedMessage<TestDevice::ScheduleWorkDifferentThreadResponse>& _msg);
+ static void GetDoneEventRequest(const ::fidl::DecodedMessage<TestDevice::GetDoneEventRequest>& _msg);
+ static void GetDoneEventResponse(const ::fidl::DecodedMessage<TestDevice::GetDoneEventResponse>& _msg);
+ static void ScheduledWorkRanRequest(const ::fidl::DecodedMessage<TestDevice::ScheduledWorkRanRequest>& _msg);
+ static void ScheduledWorkRanResponse(const ::fidl::DecodedMessage<TestDevice::ScheduledWorkRanResponse>& _msg);
+ static void GetChannelRequest(const ::fidl::DecodedMessage<TestDevice::GetChannelRequest>& _msg);
+ static void GetChannelResponse(const ::fidl::DecodedMessage<TestDevice::GetChannelResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_OwnedChannelDevice_ScheduleWork_ResponseTable;
+
+struct OwnedChannelDevice_ScheduleWork_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_OwnedChannelDevice_ScheduleWork_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_OwnedChannelDeviceScheduleWorkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_schedule_work_test_OwnedChannelDeviceScheduleWorkResponseTable;
+
+class OwnedChannelDevice final {
+ OwnedChannelDevice() = delete;
+ public:
+
+ struct ScheduleWorkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_OwnedChannelDeviceScheduleWorkResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 80;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ScheduleWorkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t batch_size;
+ uint32_t num_work_items;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_schedule_work_test_OwnedChannelDeviceScheduleWorkRequestTable;
+ 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 = ScheduleWorkResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class ScheduleWork_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ScheduleWork_Impl(::zx::unowned_channel _client_end, uint32_t batch_size, uint32_t num_work_items);
+ ~ScheduleWork_Impl() = default;
+ ScheduleWork_Impl(ScheduleWork_Impl&& other) = default;
+ ScheduleWork_Impl& operator=(ScheduleWork_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 ScheduleWork = ScheduleWork_Impl<ScheduleWorkResponse>;
+ };
+
+ // 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 ScheduleWork_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ScheduleWork_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::fidl::BytePart _response_buffer);
+ ~ScheduleWork_Impl() = default;
+ ScheduleWork_Impl(ScheduleWork_Impl&& other) = default;
+ ScheduleWork_Impl& operator=(ScheduleWork_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 ScheduleWork = ScheduleWork_Impl<ScheduleWorkResponse>;
+ };
+
+ 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_; }
+
+ // Schedules work and blocks until it completes. |batch_size| refers to how
+ // many work_items to keep outstanding at any given time, while
+ // |num_work_items| refers to total number of work items.
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ScheduleWork ScheduleWork(uint32_t batch_size, uint32_t num_work_items);
+
+ // Schedules work and blocks until it completes. |batch_size| refers to how
+ // many work_items to keep outstanding at any given time, while
+ // |num_work_items| refers to total number of work items.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ScheduleWork ScheduleWork(::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::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:
+
+ // Schedules work and blocks until it completes. |batch_size| refers to how
+ // many work_items to keep outstanding at any given time, while
+ // |num_work_items| refers to total number of work items.
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ScheduleWork ScheduleWork(::zx::unowned_channel _client_end, uint32_t batch_size, uint32_t num_work_items);
+
+ // Schedules work and blocks until it completes. |batch_size| refers to how
+ // many work_items to keep outstanding at any given time, while
+ // |num_work_items| refers to total number of work items.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ScheduleWork ScheduleWork(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t batch_size, uint32_t num_work_items, ::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:
+
+ // Schedules work and blocks until it completes. |batch_size| refers to how
+ // many work_items to keep outstanding at any given time, while
+ // |num_work_items| refers to total number of work items.
+ static ::fidl::DecodeResult<ScheduleWorkResponse> ScheduleWork(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ScheduleWorkRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = OwnedChannelDevice;
+ using _Base = ::fidl::CompleterBase;
+
+ class ScheduleWorkCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Result result);
+ void ReplySuccess(::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram histogram);
+ void Reply(::fidl::DecodedMessage<ScheduleWorkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ScheduleWorkCompleter = ::fidl::Completer<ScheduleWorkCompleterBase>;
+
+ virtual void ScheduleWork(uint32_t batch_size, uint32_t num_work_items, ScheduleWorkCompleter::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 ScheduleWorkRequest(const ::fidl::DecodedMessage<OwnedChannelDevice::ScheduleWorkRequest>& _msg);
+ static void ScheduleWorkResponse(const ::fidl::DecodedMessage<OwnedChannelDevice::ScheduleWorkResponse>& _msg);
+ };
+};
+
+} // namespace test
+} // namespace work
+} // namespace schedule
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response) == ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWork_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response) == ::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::TestDevice_ScheduleWorkDifferentThread_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response, event) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response) == ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetDoneEvent_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response) == ::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::TestDevice_GetChannel_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram>);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram, buckets) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram) == ::llcpp::fuchsia::device::schedule::work::test::LatencyHistogram::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkRequest)
+ == ::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkRequest, batch_size) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkRequest, num_work_items) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkResponse)
+ == ::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkDifferentThreadResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkDifferentThreadResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkDifferentThreadResponse)
+ == ::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkDifferentThreadResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduleWorkDifferentThreadResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetDoneEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetDoneEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetDoneEventResponse)
+ == ::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetDoneEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetDoneEventResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduledWorkRanResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduledWorkRanResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduledWorkRanResponse)
+ == ::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduledWorkRanResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduledWorkRanResponse, work_items_run) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::ScheduledWorkRanResponse, histogram) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelRequest)
+ == ::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelRequest, test) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelResponse)
+ == ::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::TestDevice::GetChannelResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response, histogram) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response) == ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice_ScheduleWork_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkRequest)
+ == ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkRequest, batch_size) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkRequest, num_work_items) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkResponse)
+ == ::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::schedule::work::test::OwnedChannelDevice::ScheduleWorkResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/dev/test/devhost-test/gen/llcpp/fidl.cc b/zircon/system/dev/test/devhost-test/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..c7aaf45
--- /dev/null
+++ b/zircon/system/dev/test/devhost-test/gen/llcpp/fidl.cc
@@ -0,0 +1,204 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/device/devhost/test/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace devhost {
+namespace test {
+
+void ::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(TestDevice_AddChildDevice_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(TestDevice_AddChildDevice_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(TestDevice_AddChildDevice_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_AddChildDevice_Ordinal = 0x1164758100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestDevice_AddChildDevice_GenOrdinal = 0x556f822500b898eclu;
+extern "C" const fidl_type_t v1_fuchsia_device_devhost_test_TestDeviceAddChildDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_devhost_test_TestDeviceAddChildDeviceResponseTable;
+
+} // namespace
+template <>
+TestDevice::ResultOf::AddChildDevice_Impl<TestDevice::AddChildDeviceResponse>::AddChildDevice_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddChildDeviceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AddChildDeviceRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddChildDeviceRequest));
+ ::fidl::DecodedMessage<AddChildDeviceRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestDevice::InPlace::AddChildDevice(std::move(_client_end), Super::response_buffer()));
+}
+
+TestDevice::ResultOf::AddChildDevice TestDevice::SyncClient::AddChildDevice() {
+ return ResultOf::AddChildDevice(::zx::unowned_channel(this->channel_));
+}
+
+TestDevice::ResultOf::AddChildDevice TestDevice::Call::AddChildDevice(::zx::unowned_channel _client_end) {
+ return ResultOf::AddChildDevice(std::move(_client_end));
+}
+
+template <>
+TestDevice::UnownedResultOf::AddChildDevice_Impl<TestDevice::AddChildDeviceResponse>::AddChildDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(AddChildDeviceRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, AddChildDeviceRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(AddChildDeviceRequest));
+ ::fidl::DecodedMessage<AddChildDeviceRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestDevice::InPlace::AddChildDevice(std::move(_client_end), std::move(_response_buffer)));
+}
+
+TestDevice::UnownedResultOf::AddChildDevice TestDevice::SyncClient::AddChildDevice(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddChildDevice(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+TestDevice::UnownedResultOf::AddChildDevice TestDevice::Call::AddChildDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddChildDevice(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestDevice::AddChildDeviceResponse> TestDevice::InPlace::AddChildDevice(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(AddChildDeviceRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<AddChildDeviceRequest> params(std::move(_request_buffer));
+ TestDevice::SetTransactionHeaderFor::AddChildDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::AddChildDeviceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AddChildDeviceRequest, AddChildDeviceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestDevice::AddChildDeviceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool TestDevice::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kTestDevice_AddChildDevice_Ordinal:
+ case kTestDevice_AddChildDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddChildDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->AddChildDevice(
+ Interface::AddChildDeviceCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool TestDevice::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void TestDevice::Interface::AddChildDeviceCompleterBase::Reply(::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddChildDeviceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AddChildDeviceResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::AddChildDeviceResponse(
+ ::fidl::DecodedMessage<AddChildDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddChildDeviceResponse::PrimarySize,
+ AddChildDeviceResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::AddChildDeviceCompleterBase::ReplySuccess() {
+ TestDevice_AddChildDevice_Response response;
+
+ Reply(TestDevice_AddChildDevice_Result::WithResponse(&response));
+}
+void TestDevice::Interface::AddChildDeviceCompleterBase::ReplyError(int32_t error) {
+ Reply(TestDevice_AddChildDevice_Result::WithErr(&error));
+}
+
+void TestDevice::Interface::AddChildDeviceCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Result result) {
+ if (_buffer.capacity() < AddChildDeviceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AddChildDeviceResponse _response = {};
+ TestDevice::SetTransactionHeaderFor::AddChildDeviceResponse(
+ ::fidl::DecodedMessage<AddChildDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddChildDeviceResponse::PrimarySize,
+ AddChildDeviceResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void TestDevice::Interface::AddChildDeviceCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ TestDevice_AddChildDevice_Response response;
+
+ Reply(std::move(_buffer), TestDevice_AddChildDevice_Result::WithResponse(&response));
+}
+
+void TestDevice::Interface::AddChildDeviceCompleterBase::Reply(::fidl::DecodedMessage<AddChildDeviceResponse> params) {
+ TestDevice::SetTransactionHeaderFor::AddChildDeviceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void TestDevice::SetTransactionHeaderFor::AddChildDeviceRequest(const ::fidl::DecodedMessage<TestDevice::AddChildDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_AddChildDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestDevice::SetTransactionHeaderFor::AddChildDeviceResponse(const ::fidl::DecodedMessage<TestDevice::AddChildDeviceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestDevice_AddChildDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace test
+} // namespace devhost
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/dev/test/devhost-test/gen/llcpp/include/fuchsia/device/devhost/test/llcpp/fidl.h b/zircon/system/dev/test/devhost-test/gen/llcpp/include/fuchsia/device/devhost/test/llcpp/fidl.h
new file mode 100644
index 0000000..3ad54e5
--- /dev/null
+++ b/zircon/system/dev/test/devhost-test/gen/llcpp/include/fuchsia/device/devhost/test/llcpp/fidl.h
@@ -0,0 +1,334 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace devhost {
+namespace test {
+
+struct TestDevice_AddChildDevice_Response;
+struct TestDevice_AddChildDevice_Result;
+class TestDevice;
+
+extern "C" const fidl_type_t v1_fuchsia_device_devhost_test_TestDevice_AddChildDevice_ResultTable;
+
+struct TestDevice_AddChildDevice_Result {
+ TestDevice_AddChildDevice_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static TestDevice_AddChildDevice_Result WithResponse(::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response* val) {
+ TestDevice_AddChildDevice_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static TestDevice_AddChildDevice_Result WithErr(int32_t* val) {
+ TestDevice_AddChildDevice_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_devhost_test_TestDevice_AddChildDevice_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_devhost_test_TestDevice_AddChildDevice_ResponseTable;
+
+struct TestDevice_AddChildDevice_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_devhost_test_TestDevice_AddChildDevice_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_devhost_test_TestDeviceAddChildDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_devhost_test_TestDeviceAddChildDeviceResponseTable;
+
+class TestDevice final {
+ TestDevice() = delete;
+ public:
+
+ struct AddChildDeviceResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_devhost_test_TestDeviceAddChildDeviceResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using AddChildDeviceRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class AddChildDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AddChildDevice_Impl(::zx::unowned_channel _client_end);
+ ~AddChildDevice_Impl() = default;
+ AddChildDevice_Impl(AddChildDevice_Impl&& other) = default;
+ AddChildDevice_Impl& operator=(AddChildDevice_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 AddChildDevice = AddChildDevice_Impl<AddChildDeviceResponse>;
+ };
+
+ // 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 AddChildDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AddChildDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~AddChildDevice_Impl() = default;
+ AddChildDevice_Impl(AddChildDevice_Impl&& other) = default;
+ AddChildDevice_Impl& operator=(AddChildDevice_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 AddChildDevice = AddChildDevice_Impl<AddChildDeviceResponse>;
+ };
+
+ 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_; }
+
+ // Add child test device
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AddChildDevice AddChildDevice();
+
+ // Add child test device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddChildDevice AddChildDevice(::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:
+
+ // Add child test device
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AddChildDevice AddChildDevice(::zx::unowned_channel _client_end);
+
+ // Add child test device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddChildDevice AddChildDevice(::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:
+
+ // Add child test device
+ static ::fidl::DecodeResult<AddChildDeviceResponse> AddChildDevice(::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 = TestDevice;
+ using _Base = ::fidl::CompleterBase;
+
+ class AddChildDeviceCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<AddChildDeviceResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AddChildDeviceCompleter = ::fidl::Completer<AddChildDeviceCompleterBase>;
+
+ virtual void AddChildDevice(AddChildDeviceCompleter::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 AddChildDeviceRequest(const ::fidl::DecodedMessage<TestDevice::AddChildDeviceRequest>& _msg);
+ static void AddChildDeviceResponse(const ::fidl::DecodedMessage<TestDevice::AddChildDeviceResponse>& _msg);
+ };
+};
+
+} // namespace test
+} // namespace devhost
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response) == ::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::devhost::test::TestDevice_AddChildDevice_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::devhost::test::TestDevice::AddChildDeviceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::devhost::test::TestDevice::AddChildDeviceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::devhost::test::TestDevice::AddChildDeviceResponse)
+ == ::llcpp::fuchsia::device::devhost::test::TestDevice::AddChildDeviceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::devhost::test::TestDevice::AddChildDeviceResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/dev/test/fuchsia-hardware-test/gen/llcpp/fidl.cc b/zircon/system/dev/test/fuchsia-hardware-test/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..a00ca54
--- /dev/null
+++ b/zircon/system/dev/test/fuchsia-hardware-test/gen/llcpp/fidl.cc
@@ -0,0 +1,174 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/test/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace test {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetChannel_Ordinal = 0x3ee7275100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetChannel_GenOrdinal = 0x3427354841fda60alu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_test_DeviceGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_test_DeviceGetChannelResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetChannel_Impl<Device::GetChannelResponse>::GetChannel_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChannelRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetChannelRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetChannel(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetChannel Device::SyncClient::GetChannel() {
+ return ResultOf::GetChannel(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetChannel Device::Call::GetChannel(::zx::unowned_channel _client_end) {
+ return ResultOf::GetChannel(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetChannel_Impl<Device::GetChannelResponse>::GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetChannelRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetChannelRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetChannel(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetChannel Device::SyncClient::GetChannel(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetChannel(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetChannel Device::Call::GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetChannel(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetChannelResponse> Device::InPlace::GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetChannelRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetChannelRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetChannelRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetChannelResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetChannelRequest, GetChannelResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetChannelResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetChannel_Ordinal:
+ case kDevice_GetChannel_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetChannelRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetChannel(
+ Interface::GetChannelCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetChannelCompleterBase::Reply(::zx::channel ch) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChannelResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetChannelResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetChannelResponse(
+ ::fidl::DecodedMessage<GetChannelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetChannelResponse::PrimarySize,
+ GetChannelResponse::PrimarySize)));
+ _response.ch = std::move(ch);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChannelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetChannelResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetChannelCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::channel ch) {
+ if (_buffer.capacity() < GetChannelResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetChannelResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetChannelResponse(
+ ::fidl::DecodedMessage<GetChannelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetChannelResponse::PrimarySize,
+ GetChannelResponse::PrimarySize)));
+ _response.ch = std::move(ch);
+ _buffer.set_actual(sizeof(GetChannelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetChannelResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetChannelCompleterBase::Reply(::fidl::DecodedMessage<GetChannelResponse> params) {
+ Device::SetTransactionHeaderFor::GetChannelResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetChannelRequest(const ::fidl::DecodedMessage<Device::GetChannelRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetChannelResponse(const ::fidl::DecodedMessage<Device::GetChannelResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace test
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/dev/test/fuchsia-hardware-test/gen/llcpp/include/fuchsia/hardware/test/llcpp/fidl.h b/zircon/system/dev/test/fuchsia-hardware-test/gen/llcpp/include/fuchsia/hardware/test/llcpp/fidl.h
new file mode 100644
index 0000000..f0b4a42
--- /dev/null
+++ b/zircon/system/dev/test/fuchsia-hardware-test/gen/llcpp/include/fuchsia/hardware/test/llcpp/fidl.h
@@ -0,0 +1,215 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace test {
+
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_test_DeviceGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_test_DeviceGetChannelResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetChannelResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel ch;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_test_DeviceGetChannelResponseTable;
+ 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 GetChannelRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetChannel_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_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 GetChannel = GetChannel_Impl<GetChannelResponse>;
+ };
+
+ // 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 GetChannel_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_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 GetChannel = GetChannel_Impl<GetChannelResponse>;
+ };
+
+ 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 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetChannel GetChannel();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetChannel GetChannel(::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 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetChannel GetChannel(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetChannel GetChannel(::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<GetChannelResponse> GetChannel(::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 = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetChannelCompleterBase : public _Base {
+ public:
+ void Reply(::zx::channel ch);
+ void Reply(::fidl::BytePart _buffer, ::zx::channel ch);
+ void Reply(::fidl::DecodedMessage<GetChannelResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetChannelCompleter = ::fidl::Completer<GetChannelCompleterBase>;
+
+ virtual void GetChannel(GetChannelCompleter::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 GetChannelRequest(const ::fidl::DecodedMessage<Device::GetChannelRequest>& _msg);
+ static void GetChannelResponse(const ::fidl::DecodedMessage<Device::GetChannelResponse>& _msg);
+ };
+};
+
+} // namespace test
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::test::Device::GetChannelResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::test::Device::GetChannelResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::test::Device::GetChannelResponse)
+ == ::llcpp::fuchsia::hardware::test::Device::GetChannelResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::test::Device::GetChannelResponse, ch) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/dev/test/mock-device/gen/llcpp/fidl.cc b/zircon/system/dev/test/mock-device/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..a811de0
--- /dev/null
+++ b/zircon/system/dev/test/mock-device/gen/llcpp/fidl.cc
@@ -0,0 +1,2437 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/device/mock/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace mock {
+
+void ::llcpp::fuchsia::device::mock::Action::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Action) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Action, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Action, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kMockDeviceThread_PerformActions_Ordinal = 0x4368272e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDeviceThread_PerformActions_GenOrdinal = 0x1e51d6eb0ce75baclu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadPerformActionsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadPerformActionsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDeviceThread_AddDeviceDone_Ordinal = 0x5a75b43900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDeviceThread_AddDeviceDone_GenOrdinal = 0x5f70f15bcdf559belu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadAddDeviceDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadAddDeviceDoneEventTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDeviceThread_UnbindReplyDone_Ordinal = 0x6c9ed25d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDeviceThread_UnbindReplyDone_GenOrdinal = 0x7cadbb1dcfd931b3lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadUnbindReplyDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadUnbindReplyDoneEventTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDeviceThread_SuspendReplyDone_Ordinal = 0x17b00f4e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDeviceThread_SuspendReplyDone_GenOrdinal = 0x158f6f5c096bef9elu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadSuspendReplyDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadSuspendReplyDoneEventTable;
+
+} // namespace
+
+MockDeviceThread::ResultOf::PerformActions_Impl::PerformActions_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PerformActionsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ PerformActionsRequest _request = {};
+ _request.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<PerformActionsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ MockDeviceThread::InPlace::PerformActions(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDeviceThread::ResultOf::PerformActions MockDeviceThread::SyncClient::PerformActions(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ return ResultOf::PerformActions(::zx::unowned_channel(this->channel_), std::move(actions));
+}
+
+MockDeviceThread::ResultOf::PerformActions MockDeviceThread::Call::PerformActions(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ return ResultOf::PerformActions(std::move(_client_end), std::move(actions));
+}
+
+
+MockDeviceThread::UnownedResultOf::PerformActions_Impl::PerformActions_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_request_buffer.capacity() < PerformActionsRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ PerformActionsRequest _request = {};
+ _request.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<PerformActionsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ MockDeviceThread::InPlace::PerformActions(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDeviceThread::UnownedResultOf::PerformActions MockDeviceThread::SyncClient::PerformActions(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ return UnownedResultOf::PerformActions(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(actions));
+}
+
+MockDeviceThread::UnownedResultOf::PerformActions MockDeviceThread::Call::PerformActions(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ return UnownedResultOf::PerformActions(std::move(_client_end), std::move(_request_buffer), std::move(actions));
+}
+
+::fidl::internal::StatusAndError MockDeviceThread::InPlace::PerformActions(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PerformActionsRequest> params) {
+ MockDeviceThread::SetTransactionHeaderFor::PerformActionsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+zx_status_t MockDeviceThread::SyncClient::HandleEvents(MockDeviceThread::EventHandlers handlers) {
+ return MockDeviceThread::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t MockDeviceThread::Call::HandleEvents(::zx::unowned_channel client_end, MockDeviceThread::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<AddDeviceDoneResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<AddDeviceDoneResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ if (::fidl::internal::ClampedMessageSize<UnbindReplyDoneResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<UnbindReplyDoneResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ if (::fidl::internal::ClampedMessageSize<SuspendReplyDoneResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<SuspendReplyDoneResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (AddDeviceDoneResponse::MaxNumHandles >= x) {
+ x = AddDeviceDoneResponse::MaxNumHandles;
+ }
+ if (UnbindReplyDoneResponse::MaxNumHandles >= x) {
+ x = UnbindReplyDoneResponse::MaxNumHandles;
+ }
+ if (SuspendReplyDoneResponse::MaxNumHandles >= x) {
+ x = SuspendReplyDoneResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kMockDeviceThread_AddDeviceDone_Ordinal:
+ case kMockDeviceThread_AddDeviceDone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddDeviceDoneResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.add_device_done(std::move(message->action_id));
+ }
+ case kMockDeviceThread_UnbindReplyDone_Ordinal:
+ case kMockDeviceThread_UnbindReplyDone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnbindReplyDoneResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.unbind_reply_done(std::move(message->action_id));
+ }
+ case kMockDeviceThread_SuspendReplyDone_Ordinal:
+ case kMockDeviceThread_SuspendReplyDone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SuspendReplyDoneResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.suspend_reply_done(std::move(message->action_id));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool MockDeviceThread::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kMockDeviceThread_PerformActions_Ordinal:
+ case kMockDeviceThread_PerformActions_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<PerformActionsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->PerformActions(std::move(message->actions),
+ Interface::PerformActionsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool MockDeviceThread::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+zx_status_t MockDeviceThread::SendAddDeviceDoneEvent(::zx::unowned_channel _chan, uint64_t action_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceDoneResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<AddDeviceDoneResponse*>(_write_bytes);
+ MockDeviceThread::SetTransactionHeaderFor::AddDeviceDoneResponse(
+ ::fidl::DecodedMessage<AddDeviceDoneResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddDeviceDoneResponse::PrimarySize,
+ AddDeviceDoneResponse::PrimarySize)));
+ _response.action_id = std::move(action_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddDeviceDoneResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<AddDeviceDoneResponse>(std::move(_response_bytes)));
+}
+
+zx_status_t MockDeviceThread::SendAddDeviceDoneEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t action_id) {
+ if (_buffer.capacity() < AddDeviceDoneResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ auto& _response = *reinterpret_cast<AddDeviceDoneResponse*>(_buffer.data());
+ MockDeviceThread::SetTransactionHeaderFor::AddDeviceDoneResponse(
+ ::fidl::DecodedMessage<AddDeviceDoneResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddDeviceDoneResponse::PrimarySize,
+ AddDeviceDoneResponse::PrimarySize)));
+ _response.action_id = std::move(action_id);
+ _buffer.set_actual(sizeof(AddDeviceDoneResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<AddDeviceDoneResponse>(std::move(_buffer)));
+}
+
+zx_status_t MockDeviceThread::SendAddDeviceDoneEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<AddDeviceDoneResponse> params) {
+ MockDeviceThread::SetTransactionHeaderFor::AddDeviceDoneResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+zx_status_t MockDeviceThread::SendUnbindReplyDoneEvent(::zx::unowned_channel _chan, uint64_t action_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindReplyDoneResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<UnbindReplyDoneResponse*>(_write_bytes);
+ MockDeviceThread::SetTransactionHeaderFor::UnbindReplyDoneResponse(
+ ::fidl::DecodedMessage<UnbindReplyDoneResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnbindReplyDoneResponse::PrimarySize,
+ UnbindReplyDoneResponse::PrimarySize)));
+ _response.action_id = std::move(action_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnbindReplyDoneResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<UnbindReplyDoneResponse>(std::move(_response_bytes)));
+}
+
+zx_status_t MockDeviceThread::SendUnbindReplyDoneEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t action_id) {
+ if (_buffer.capacity() < UnbindReplyDoneResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ auto& _response = *reinterpret_cast<UnbindReplyDoneResponse*>(_buffer.data());
+ MockDeviceThread::SetTransactionHeaderFor::UnbindReplyDoneResponse(
+ ::fidl::DecodedMessage<UnbindReplyDoneResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnbindReplyDoneResponse::PrimarySize,
+ UnbindReplyDoneResponse::PrimarySize)));
+ _response.action_id = std::move(action_id);
+ _buffer.set_actual(sizeof(UnbindReplyDoneResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<UnbindReplyDoneResponse>(std::move(_buffer)));
+}
+
+zx_status_t MockDeviceThread::SendUnbindReplyDoneEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<UnbindReplyDoneResponse> params) {
+ MockDeviceThread::SetTransactionHeaderFor::UnbindReplyDoneResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+zx_status_t MockDeviceThread::SendSuspendReplyDoneEvent(::zx::unowned_channel _chan, uint64_t action_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendReplyDoneResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SuspendReplyDoneResponse*>(_write_bytes);
+ MockDeviceThread::SetTransactionHeaderFor::SuspendReplyDoneResponse(
+ ::fidl::DecodedMessage<SuspendReplyDoneResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendReplyDoneResponse::PrimarySize,
+ SuspendReplyDoneResponse::PrimarySize)));
+ _response.action_id = std::move(action_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendReplyDoneResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<SuspendReplyDoneResponse>(std::move(_response_bytes)));
+}
+
+zx_status_t MockDeviceThread::SendSuspendReplyDoneEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t action_id) {
+ if (_buffer.capacity() < SuspendReplyDoneResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ auto& _response = *reinterpret_cast<SuspendReplyDoneResponse*>(_buffer.data());
+ MockDeviceThread::SetTransactionHeaderFor::SuspendReplyDoneResponse(
+ ::fidl::DecodedMessage<SuspendReplyDoneResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendReplyDoneResponse::PrimarySize,
+ SuspendReplyDoneResponse::PrimarySize)));
+ _response.action_id = std::move(action_id);
+ _buffer.set_actual(sizeof(SuspendReplyDoneResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<SuspendReplyDoneResponse>(std::move(_buffer)));
+}
+
+zx_status_t MockDeviceThread::SendSuspendReplyDoneEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<SuspendReplyDoneResponse> params) {
+ MockDeviceThread::SetTransactionHeaderFor::SuspendReplyDoneResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+
+void MockDeviceThread::SetTransactionHeaderFor::PerformActionsRequest(const ::fidl::DecodedMessage<MockDeviceThread::PerformActionsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDeviceThread_PerformActions_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDeviceThread::SetTransactionHeaderFor::AddDeviceDoneResponse(const ::fidl::DecodedMessage<MockDeviceThread::AddDeviceDoneResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDeviceThread_AddDeviceDone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDeviceThread::SetTransactionHeaderFor::UnbindReplyDoneResponse(const ::fidl::DecodedMessage<MockDeviceThread::UnbindReplyDoneResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDeviceThread_UnbindReplyDone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDeviceThread::SetTransactionHeaderFor::SuspendReplyDoneResponse(const ::fidl::DecodedMessage<MockDeviceThread::SuspendReplyDoneResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDeviceThread_SuspendReplyDone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Bind_Ordinal = 0x7c80f6ec00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Bind_GenOrdinal = 0x61f85ea4a79aaf98lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceBindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Release_Ordinal = 0x244f460200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Release_GenOrdinal = 0x3e34cd45b096f7dflu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceReleaseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceReleaseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_GetProtocol_Ordinal = 0x2260377000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_GetProtocol_GenOrdinal = 0x4b589335ced5818flu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceGetProtocolRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceGetProtocolResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Open_Ordinal = 0x78822f4600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Open_GenOrdinal = 0x667693e248252a7blu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceOpenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Close_Ordinal = 0x1cb8023800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Close_GenOrdinal = 0x77d1ae25197af4b4lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Unbind_Ordinal = 0x4184fddd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Unbind_GenOrdinal = 0x5edfb40dac65de1alu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceUnbindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceUnbindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Read_Ordinal = 0x58b86c9100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Read_GenOrdinal = 0x59a0e040f263ce78lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceReadResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Write_Ordinal = 0x58d75faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Write_GenOrdinal = 0x4093b59b2ed5bc84lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceWriteResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_GetSize_Ordinal = 0xadc36e600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_GetSize_GenOrdinal = 0x2fd05ce2a771bba2lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceGetSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceGetSizeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Suspend_Ordinal = 0x3a4dd8cb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Suspend_GenOrdinal = 0x1d086b1540c8badalu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceSuspendResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Resume_Ordinal = 0x6f537db800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Resume_GenOrdinal = 0x405f391966e368celu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceResumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceResumeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Message_Ordinal = 0x52488df800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Message_GenOrdinal = 0x7a14d769ce9e8b14lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceMessageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceMessageResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Rxrpc_Ordinal = 0x2e6fd1b900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_Rxrpc_GenOrdinal = 0x24f0a836490f4a99lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceRxrpcRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceRxrpcResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_AddDeviceDone_Ordinal = 0x10d0aadc00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_AddDeviceDone_GenOrdinal = 0x40fd824a0e920396lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceAddDeviceDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceAddDeviceDoneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_UnbindReplyDone_Ordinal = 0x4d0946a100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_UnbindReplyDone_GenOrdinal = 0x6f057a72a4b6c2e8lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceUnbindReplyDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceUnbindReplyDoneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_SuspendReplyDone_Ordinal = 0x2786b91000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMockDevice_SuspendReplyDone_GenOrdinal = 0x457f0f17b95a8de1lu;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceSuspendReplyDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceSuspendReplyDoneResponseTable;
+
+} // namespace
+template <>
+MockDevice::ResultOf::Bind_Impl<MockDevice::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, BindRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<BindRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(BindRequest));
+ ::fidl::DecodedMessage<BindRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Bind MockDevice::SyncClient::Bind(::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(record));
+}
+
+MockDevice::ResultOf::Bind MockDevice::Call::Bind(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Bind(std::move(_client_end), std::move(record));
+}
+
+template <>
+MockDevice::UnownedResultOf::Bind_Impl<MockDevice::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BindRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BindResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, BindRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<BindRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request_buffer.set_actual(sizeof(BindRequest));
+ ::fidl::DecodedMessage<BindRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Bind MockDevice::SyncClient::Bind(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Bind MockDevice::Call::Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::BindResponse> MockDevice::InPlace::Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::BindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::BindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BindRequest, BindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::BindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+MockDevice::ResultOf::Release_Impl::Release_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReleaseRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReleaseRequest));
+ ::fidl::DecodedMessage<ReleaseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ MockDevice::InPlace::Release(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDevice::ResultOf::Release MockDevice::SyncClient::Release(::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Release(::zx::unowned_channel(this->channel_), std::move(record));
+}
+
+MockDevice::ResultOf::Release MockDevice::Call::Release(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Release(std::move(_client_end), std::move(record));
+}
+
+
+MockDevice::UnownedResultOf::Release_Impl::Release_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ if (_request_buffer.capacity() < ReleaseRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReleaseRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request_buffer.set_actual(sizeof(ReleaseRequest));
+ ::fidl::DecodedMessage<ReleaseRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ MockDevice::InPlace::Release(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDevice::UnownedResultOf::Release MockDevice::SyncClient::Release(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return UnownedResultOf::Release(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record));
+}
+
+MockDevice::UnownedResultOf::Release MockDevice::Call::Release(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return UnownedResultOf::Release(std::move(_client_end), std::move(_request_buffer), std::move(record));
+}
+
+::fidl::internal::StatusAndError MockDevice::InPlace::Release(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseRequest> params) {
+ MockDevice::SetTransactionHeaderFor::ReleaseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+MockDevice::ResultOf::GetProtocol_Impl<MockDevice::GetProtocolResponse>::GetProtocol_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetProtocolRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetProtocolRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetProtocolRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ _request.protocol_id = std::move(protocol_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetProtocolRequest));
+ ::fidl::DecodedMessage<GetProtocolRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::GetProtocol(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::GetProtocol MockDevice::SyncClient::GetProtocol(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id) {
+ return ResultOf::GetProtocol(::zx::unowned_channel(this->channel_), std::move(record), std::move(protocol_id));
+}
+
+MockDevice::ResultOf::GetProtocol MockDevice::Call::GetProtocol(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id) {
+ return ResultOf::GetProtocol(std::move(_client_end), std::move(record), std::move(protocol_id));
+}
+
+template <>
+MockDevice::UnownedResultOf::GetProtocol_Impl<MockDevice::GetProtocolResponse>::GetProtocol_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetProtocolRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetProtocolResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetProtocolRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetProtocolRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request.protocol_id = std::move(protocol_id);
+ _request_buffer.set_actual(sizeof(GetProtocolRequest));
+ ::fidl::DecodedMessage<GetProtocolRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::GetProtocol(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::GetProtocol MockDevice::SyncClient::GetProtocol(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetProtocol(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(protocol_id), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::GetProtocol MockDevice::Call::GetProtocol(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetProtocol(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(protocol_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::GetProtocolResponse> MockDevice::InPlace::GetProtocol(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetProtocolRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::GetProtocolRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::GetProtocolResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetProtocolRequest, GetProtocolResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::GetProtocolResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Open_Impl<MockDevice::OpenResponse>::Open_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, OpenRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OpenRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OpenRequest));
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Open(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Open MockDevice::SyncClient::Open(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ return ResultOf::Open(::zx::unowned_channel(this->channel_), std::move(record), std::move(flags));
+}
+
+MockDevice::ResultOf::Open MockDevice::Call::Open(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ return ResultOf::Open(std::move(_client_end), std::move(record), std::move(flags));
+}
+
+template <>
+MockDevice::UnownedResultOf::Open_Impl<MockDevice::OpenResponse>::Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < OpenRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<OpenResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, OpenRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OpenRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(OpenRequest));
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Open(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Open MockDevice::SyncClient::Open(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Open(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(flags), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Open MockDevice::Call::Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Open(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::OpenResponse> MockDevice::InPlace::Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::OpenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::OpenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<OpenRequest, OpenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::OpenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Close_Impl<MockDevice::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloseRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Close(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Close MockDevice::SyncClient::Close(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_), std::move(record), std::move(flags));
+}
+
+MockDevice::ResultOf::Close MockDevice::Call::Close(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ return ResultOf::Close(std::move(_client_end), std::move(record), std::move(flags));
+}
+
+template <>
+MockDevice::UnownedResultOf::Close_Impl<MockDevice::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CloseRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CloseResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloseRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Close(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Close MockDevice::SyncClient::Close(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(flags), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Close MockDevice::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::CloseResponse> MockDevice::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloseRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Unbind_Impl<MockDevice::UnbindResponse>::Unbind_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, UnbindRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<UnbindRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnbindRequest));
+ ::fidl::DecodedMessage<UnbindRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Unbind(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Unbind MockDevice::SyncClient::Unbind(::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Unbind(::zx::unowned_channel(this->channel_), std::move(record));
+}
+
+MockDevice::ResultOf::Unbind MockDevice::Call::Unbind(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Unbind(std::move(_client_end), std::move(record));
+}
+
+template <>
+MockDevice::UnownedResultOf::Unbind_Impl<MockDevice::UnbindResponse>::Unbind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UnbindRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UnbindResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, UnbindRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<UnbindRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request_buffer.set_actual(sizeof(UnbindRequest));
+ ::fidl::DecodedMessage<UnbindRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Unbind(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Unbind MockDevice::SyncClient::Unbind(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unbind(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Unbind MockDevice::Call::Unbind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unbind(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::UnbindResponse> MockDevice::InPlace::Unbind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnbindRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::UnbindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::UnbindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnbindRequest, UnbindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::UnbindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Read_Impl<MockDevice::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ _request.count = std::move(count);
+ _request.off = std::move(off);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Read(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Read MockDevice::SyncClient::Read(::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off) {
+ return ResultOf::Read(::zx::unowned_channel(this->channel_), std::move(record), std::move(count), std::move(off));
+}
+
+MockDevice::ResultOf::Read MockDevice::Call::Read(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off) {
+ return ResultOf::Read(std::move(_client_end), std::move(record), std::move(count), std::move(off));
+}
+
+template <>
+MockDevice::UnownedResultOf::Read_Impl<MockDevice::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request.count = std::move(count);
+ _request.off = std::move(off);
+ _request_buffer.set_actual(sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Read(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Read MockDevice::SyncClient::Read(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(count), std::move(off), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Read MockDevice::Call::Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(count), std::move(off), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::ReadResponse> MockDevice::InPlace::Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::ReadRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::ReadResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadRequest, ReadResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::ReadResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Write_Impl<MockDevice::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteRequest _request = {};
+ _request.record = std::move(record);
+ _request.buffer = std::move(buffer);
+ _request.off = std::move(off);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ MockDevice::InPlace::Write(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Write MockDevice::SyncClient::Write(::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off) {
+ return ResultOf::Write(::zx::unowned_channel(this->channel_), std::move(record), std::move(buffer), std::move(off));
+}
+
+MockDevice::ResultOf::Write MockDevice::Call::Write(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off) {
+ return ResultOf::Write(std::move(_client_end), std::move(record), std::move(buffer), std::move(off));
+}
+
+template <>
+MockDevice::UnownedResultOf::Write_Impl<MockDevice::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteRequest _request = {};
+ _request.record = std::move(record);
+ _request.buffer = std::move(buffer);
+ _request.off = std::move(off);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ MockDevice::InPlace::Write(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Write MockDevice::SyncClient::Write(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(buffer), std::move(off), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Write MockDevice::Call::Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(buffer), std::move(off), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::WriteResponse> MockDevice::InPlace::Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::WriteRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::WriteResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::WriteResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::GetSize_Impl<MockDevice::GetSizeResponse>::GetSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSizeRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSizeRequest));
+ ::fidl::DecodedMessage<GetSizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::GetSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::GetSize MockDevice::SyncClient::GetSize(::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::GetSize(::zx::unowned_channel(this->channel_), std::move(record));
+}
+
+MockDevice::ResultOf::GetSize MockDevice::Call::GetSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::GetSize(std::move(_client_end), std::move(record));
+}
+
+template <>
+MockDevice::UnownedResultOf::GetSize_Impl<MockDevice::GetSizeResponse>::GetSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetSizeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSizeRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request_buffer.set_actual(sizeof(GetSizeRequest));
+ ::fidl::DecodedMessage<GetSizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::GetSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::GetSize MockDevice::SyncClient::GetSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::GetSize MockDevice::Call::GetSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSize(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::GetSizeResponse> MockDevice::InPlace::GetSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSizeRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::GetSizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::GetSizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSizeRequest, GetSizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::GetSizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Suspend_Impl<MockDevice::SuspendResponse>::Suspend_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ _request.requested_state = std::move(requested_state);
+ _request.enable_wake = std::move(enable_wake);
+ _request.suspend_reason = std::move(suspend_reason);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendRequest));
+ ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Suspend MockDevice::SyncClient::Suspend(::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason) {
+ return ResultOf::Suspend(::zx::unowned_channel(this->channel_), std::move(record), std::move(requested_state), std::move(enable_wake), std::move(suspend_reason));
+}
+
+MockDevice::ResultOf::Suspend MockDevice::Call::Suspend(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason) {
+ return ResultOf::Suspend(std::move(_client_end), std::move(record), std::move(requested_state), std::move(enable_wake), std::move(suspend_reason));
+}
+
+template <>
+MockDevice::UnownedResultOf::Suspend_Impl<MockDevice::SuspendResponse>::Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SuspendRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request.requested_state = std::move(requested_state);
+ _request.enable_wake = std::move(enable_wake);
+ _request.suspend_reason = std::move(suspend_reason);
+ _request_buffer.set_actual(sizeof(SuspendRequest));
+ ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Suspend MockDevice::SyncClient::Suspend(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Suspend(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(requested_state), std::move(enable_wake), std::move(suspend_reason), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Suspend MockDevice::Call::Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Suspend(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(requested_state), std::move(enable_wake), std::move(suspend_reason), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::SuspendResponse> MockDevice::InPlace::Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::SuspendRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::SuspendResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SuspendRequest, SuspendResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::SuspendResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Resume_Impl<MockDevice::ResumeResponse>::Resume_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ResumeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ResumeRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeRequest));
+ ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Resume MockDevice::SyncClient::Resume(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ return ResultOf::Resume(::zx::unowned_channel(this->channel_), std::move(record), std::move(flags));
+}
+
+MockDevice::ResultOf::Resume MockDevice::Call::Resume(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags) {
+ return ResultOf::Resume(std::move(_client_end), std::move(record), std::move(flags));
+}
+
+template <>
+MockDevice::UnownedResultOf::Resume_Impl<MockDevice::ResumeResponse>::Resume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ResumeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ResumeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ResumeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ResumeRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(ResumeRequest));
+ ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Resume MockDevice::SyncClient::Resume(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resume(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(flags), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Resume MockDevice::Call::Resume(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resume(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::ResumeResponse> MockDevice::InPlace::Resume(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::ResumeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::ResumeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ResumeRequest, ResumeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::ResumeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Message_Impl<MockDevice::MessageResponse>::Message_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MessageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, MessageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<MessageRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(MessageRequest));
+ ::fidl::DecodedMessage<MessageRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Message(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Message MockDevice::SyncClient::Message(::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Message(::zx::unowned_channel(this->channel_), std::move(record));
+}
+
+MockDevice::ResultOf::Message MockDevice::Call::Message(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Message(std::move(_client_end), std::move(record));
+}
+
+template <>
+MockDevice::UnownedResultOf::Message_Impl<MockDevice::MessageResponse>::Message_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < MessageRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<MessageResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, MessageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<MessageRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request_buffer.set_actual(sizeof(MessageRequest));
+ ::fidl::DecodedMessage<MessageRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Message(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Message MockDevice::SyncClient::Message(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Message(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Message MockDevice::Call::Message(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Message(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::MessageResponse> MockDevice::InPlace::Message(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MessageRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::MessageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::MessageResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<MessageRequest, MessageResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::MessageResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MockDevice::ResultOf::Rxrpc_Impl<MockDevice::RxrpcResponse>::Rxrpc_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RxrpcRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RxrpcRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RxrpcRequest*>(_write_bytes);
+ _request.record = std::move(record);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RxrpcRequest));
+ ::fidl::DecodedMessage<RxrpcRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MockDevice::InPlace::Rxrpc(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MockDevice::ResultOf::Rxrpc MockDevice::SyncClient::Rxrpc(::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Rxrpc(::zx::unowned_channel(this->channel_), std::move(record));
+}
+
+MockDevice::ResultOf::Rxrpc MockDevice::Call::Rxrpc(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record) {
+ return ResultOf::Rxrpc(std::move(_client_end), std::move(record));
+}
+
+template <>
+MockDevice::UnownedResultOf::Rxrpc_Impl<MockDevice::RxrpcResponse>::Rxrpc_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RxrpcRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RxrpcResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RxrpcRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RxrpcRequest*>(_request_buffer.data());
+ _request.record = std::move(record);
+ _request_buffer.set_actual(sizeof(RxrpcRequest));
+ ::fidl::DecodedMessage<RxrpcRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MockDevice::InPlace::Rxrpc(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MockDevice::UnownedResultOf::Rxrpc MockDevice::SyncClient::Rxrpc(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rxrpc(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+MockDevice::UnownedResultOf::Rxrpc MockDevice::Call::Rxrpc(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rxrpc(std::move(_client_end), std::move(_request_buffer), std::move(record), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MockDevice::RxrpcResponse> MockDevice::InPlace::Rxrpc(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RxrpcRequest> params, ::fidl::BytePart response_buffer) {
+ MockDevice::SetTransactionHeaderFor::RxrpcRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::RxrpcResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RxrpcRequest, RxrpcResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MockDevice::RxrpcResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+MockDevice::ResultOf::AddDeviceDone_Impl::AddDeviceDone_Impl(::zx::unowned_channel _client_end, uint64_t action_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceDoneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AddDeviceDoneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AddDeviceDoneRequest*>(_write_bytes);
+ _request.action_id = std::move(action_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddDeviceDoneRequest));
+ ::fidl::DecodedMessage<AddDeviceDoneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ MockDevice::InPlace::AddDeviceDone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDevice::ResultOf::AddDeviceDone MockDevice::SyncClient::AddDeviceDone(uint64_t action_id) {
+ return ResultOf::AddDeviceDone(::zx::unowned_channel(this->channel_), std::move(action_id));
+}
+
+MockDevice::ResultOf::AddDeviceDone MockDevice::Call::AddDeviceDone(::zx::unowned_channel _client_end, uint64_t action_id) {
+ return ResultOf::AddDeviceDone(std::move(_client_end), std::move(action_id));
+}
+
+
+MockDevice::UnownedResultOf::AddDeviceDone_Impl::AddDeviceDone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id) {
+ if (_request_buffer.capacity() < AddDeviceDoneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, AddDeviceDoneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AddDeviceDoneRequest*>(_request_buffer.data());
+ _request.action_id = std::move(action_id);
+ _request_buffer.set_actual(sizeof(AddDeviceDoneRequest));
+ ::fidl::DecodedMessage<AddDeviceDoneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ MockDevice::InPlace::AddDeviceDone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDevice::UnownedResultOf::AddDeviceDone MockDevice::SyncClient::AddDeviceDone(::fidl::BytePart _request_buffer, uint64_t action_id) {
+ return UnownedResultOf::AddDeviceDone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(action_id));
+}
+
+MockDevice::UnownedResultOf::AddDeviceDone MockDevice::Call::AddDeviceDone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id) {
+ return UnownedResultOf::AddDeviceDone(std::move(_client_end), std::move(_request_buffer), std::move(action_id));
+}
+
+::fidl::internal::StatusAndError MockDevice::InPlace::AddDeviceDone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceDoneRequest> params) {
+ MockDevice::SetTransactionHeaderFor::AddDeviceDoneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+MockDevice::ResultOf::UnbindReplyDone_Impl::UnbindReplyDone_Impl(::zx::unowned_channel _client_end, uint64_t action_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindReplyDoneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, UnbindReplyDoneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<UnbindReplyDoneRequest*>(_write_bytes);
+ _request.action_id = std::move(action_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnbindReplyDoneRequest));
+ ::fidl::DecodedMessage<UnbindReplyDoneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ MockDevice::InPlace::UnbindReplyDone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDevice::ResultOf::UnbindReplyDone MockDevice::SyncClient::UnbindReplyDone(uint64_t action_id) {
+ return ResultOf::UnbindReplyDone(::zx::unowned_channel(this->channel_), std::move(action_id));
+}
+
+MockDevice::ResultOf::UnbindReplyDone MockDevice::Call::UnbindReplyDone(::zx::unowned_channel _client_end, uint64_t action_id) {
+ return ResultOf::UnbindReplyDone(std::move(_client_end), std::move(action_id));
+}
+
+
+MockDevice::UnownedResultOf::UnbindReplyDone_Impl::UnbindReplyDone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id) {
+ if (_request_buffer.capacity() < UnbindReplyDoneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, UnbindReplyDoneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<UnbindReplyDoneRequest*>(_request_buffer.data());
+ _request.action_id = std::move(action_id);
+ _request_buffer.set_actual(sizeof(UnbindReplyDoneRequest));
+ ::fidl::DecodedMessage<UnbindReplyDoneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ MockDevice::InPlace::UnbindReplyDone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDevice::UnownedResultOf::UnbindReplyDone MockDevice::SyncClient::UnbindReplyDone(::fidl::BytePart _request_buffer, uint64_t action_id) {
+ return UnownedResultOf::UnbindReplyDone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(action_id));
+}
+
+MockDevice::UnownedResultOf::UnbindReplyDone MockDevice::Call::UnbindReplyDone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id) {
+ return UnownedResultOf::UnbindReplyDone(std::move(_client_end), std::move(_request_buffer), std::move(action_id));
+}
+
+::fidl::internal::StatusAndError MockDevice::InPlace::UnbindReplyDone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnbindReplyDoneRequest> params) {
+ MockDevice::SetTransactionHeaderFor::UnbindReplyDoneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+MockDevice::ResultOf::SuspendReplyDone_Impl::SuspendReplyDone_Impl(::zx::unowned_channel _client_end, uint64_t action_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendReplyDoneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SuspendReplyDoneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendReplyDoneRequest*>(_write_bytes);
+ _request.action_id = std::move(action_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendReplyDoneRequest));
+ ::fidl::DecodedMessage<SuspendReplyDoneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ MockDevice::InPlace::SuspendReplyDone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDevice::ResultOf::SuspendReplyDone MockDevice::SyncClient::SuspendReplyDone(uint64_t action_id) {
+ return ResultOf::SuspendReplyDone(::zx::unowned_channel(this->channel_), std::move(action_id));
+}
+
+MockDevice::ResultOf::SuspendReplyDone MockDevice::Call::SuspendReplyDone(::zx::unowned_channel _client_end, uint64_t action_id) {
+ return ResultOf::SuspendReplyDone(std::move(_client_end), std::move(action_id));
+}
+
+
+MockDevice::UnownedResultOf::SuspendReplyDone_Impl::SuspendReplyDone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id) {
+ if (_request_buffer.capacity() < SuspendReplyDoneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SuspendReplyDoneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendReplyDoneRequest*>(_request_buffer.data());
+ _request.action_id = std::move(action_id);
+ _request_buffer.set_actual(sizeof(SuspendReplyDoneRequest));
+ ::fidl::DecodedMessage<SuspendReplyDoneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ MockDevice::InPlace::SuspendReplyDone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MockDevice::UnownedResultOf::SuspendReplyDone MockDevice::SyncClient::SuspendReplyDone(::fidl::BytePart _request_buffer, uint64_t action_id) {
+ return UnownedResultOf::SuspendReplyDone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(action_id));
+}
+
+MockDevice::UnownedResultOf::SuspendReplyDone MockDevice::Call::SuspendReplyDone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id) {
+ return UnownedResultOf::SuspendReplyDone(std::move(_client_end), std::move(_request_buffer), std::move(action_id));
+}
+
+::fidl::internal::StatusAndError MockDevice::InPlace::SuspendReplyDone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendReplyDoneRequest> params) {
+ MockDevice::SetTransactionHeaderFor::SuspendReplyDoneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool MockDevice::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kMockDevice_Bind_Ordinal:
+ case kMockDevice_Bind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Bind(std::move(message->record),
+ Interface::BindCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Release_Ordinal:
+ case kMockDevice_Release_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReleaseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Release(std::move(message->record),
+ Interface::ReleaseCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_GetProtocol_Ordinal:
+ case kMockDevice_GetProtocol_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetProtocolRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetProtocol(std::move(message->record), std::move(message->protocol_id),
+ Interface::GetProtocolCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Open_Ordinal:
+ case kMockDevice_Open_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Open(std::move(message->record), std::move(message->flags),
+ Interface::OpenCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Close_Ordinal:
+ case kMockDevice_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Close(std::move(message->record), std::move(message->flags),
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Unbind_Ordinal:
+ case kMockDevice_Unbind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnbindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Unbind(std::move(message->record),
+ Interface::UnbindCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Read_Ordinal:
+ case kMockDevice_Read_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Read(std::move(message->record), std::move(message->count), std::move(message->off),
+ Interface::ReadCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Write_Ordinal:
+ case kMockDevice_Write_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Write(std::move(message->record), std::move(message->buffer), std::move(message->off),
+ Interface::WriteCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_GetSize_Ordinal:
+ case kMockDevice_GetSize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetSize(std::move(message->record),
+ Interface::GetSizeCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Suspend_Ordinal:
+ case kMockDevice_Suspend_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SuspendRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Suspend(std::move(message->record), std::move(message->requested_state), std::move(message->enable_wake), std::move(message->suspend_reason),
+ Interface::SuspendCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Resume_Ordinal:
+ case kMockDevice_Resume_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ResumeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Resume(std::move(message->record), std::move(message->flags),
+ Interface::ResumeCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Message_Ordinal:
+ case kMockDevice_Message_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<MessageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Message(std::move(message->record),
+ Interface::MessageCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_Rxrpc_Ordinal:
+ case kMockDevice_Rxrpc_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RxrpcRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Rxrpc(std::move(message->record),
+ Interface::RxrpcCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_AddDeviceDone_Ordinal:
+ case kMockDevice_AddDeviceDone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddDeviceDoneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddDeviceDone(std::move(message->action_id),
+ Interface::AddDeviceDoneCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_UnbindReplyDone_Ordinal:
+ case kMockDevice_UnbindReplyDone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnbindReplyDoneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UnbindReplyDone(std::move(message->action_id),
+ Interface::UnbindReplyDoneCompleter::Sync(txn));
+ return true;
+ }
+ case kMockDevice_SuspendReplyDone_Ordinal:
+ case kMockDevice_SuspendReplyDone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SuspendReplyDoneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SuspendReplyDone(std::move(message->action_id),
+ Interface::SuspendReplyDoneCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool MockDevice::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void MockDevice::Interface::BindCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ BindResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::BindCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < BindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ BindResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::BindCompleterBase::Reply(::fidl::DecodedMessage<BindResponse> params) {
+ MockDevice::SetTransactionHeaderFor::BindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::GetProtocolCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetProtocolResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetProtocolResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::GetProtocolResponse(
+ ::fidl::DecodedMessage<GetProtocolResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetProtocolResponse::PrimarySize,
+ GetProtocolResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::GetProtocolCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < GetProtocolResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetProtocolResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::GetProtocolResponse(
+ ::fidl::DecodedMessage<GetProtocolResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetProtocolResponse::PrimarySize,
+ GetProtocolResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::GetProtocolCompleterBase::Reply(::fidl::DecodedMessage<GetProtocolResponse> params) {
+ MockDevice::SetTransactionHeaderFor::GetProtocolResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::OpenCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OpenResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::OpenResponse(
+ ::fidl::DecodedMessage<OpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenResponse::PrimarySize,
+ OpenResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::OpenCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < OpenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ OpenResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::OpenResponse(
+ ::fidl::DecodedMessage<OpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenResponse::PrimarySize,
+ OpenResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::OpenCompleterBase::Reply(::fidl::DecodedMessage<OpenResponse> params) {
+ MockDevice::SetTransactionHeaderFor::OpenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::CloseCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ CloseResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CloseResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ MockDevice::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::UnbindCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ UnbindResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::UnbindResponse(
+ ::fidl::DecodedMessage<UnbindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnbindResponse::PrimarySize,
+ UnbindResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::UnbindCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < UnbindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UnbindResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::UnbindResponse(
+ ::fidl::DecodedMessage<UnbindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnbindResponse::PrimarySize,
+ UnbindResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::UnbindCompleterBase::Reply(::fidl::DecodedMessage<UnbindResponse> params) {
+ MockDevice::SetTransactionHeaderFor::UnbindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::ReadCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::ReadCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < ReadResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::ReadCompleterBase::Reply(::fidl::DecodedMessage<ReadResponse> params) {
+ MockDevice::SetTransactionHeaderFor::ReadResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::WriteCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ WriteResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::WriteCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < WriteResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WriteResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::WriteCompleterBase::Reply(::fidl::DecodedMessage<WriteResponse> params) {
+ MockDevice::SetTransactionHeaderFor::WriteResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::GetSizeCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSizeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetSizeResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::GetSizeResponse(
+ ::fidl::DecodedMessage<GetSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSizeResponse::PrimarySize,
+ GetSizeResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::GetSizeCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < GetSizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSizeResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::GetSizeResponse(
+ ::fidl::DecodedMessage<GetSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSizeResponse::PrimarySize,
+ GetSizeResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::GetSizeCompleterBase::Reply(::fidl::DecodedMessage<GetSizeResponse> params) {
+ MockDevice::SetTransactionHeaderFor::GetSizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::SuspendCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ SuspendResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::SuspendResponse(
+ ::fidl::DecodedMessage<SuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendResponse::PrimarySize,
+ SuspendResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::SuspendCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < SuspendResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SuspendResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::SuspendResponse(
+ ::fidl::DecodedMessage<SuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendResponse::PrimarySize,
+ SuspendResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::SuspendCompleterBase::Reply(::fidl::DecodedMessage<SuspendResponse> params) {
+ MockDevice::SetTransactionHeaderFor::SuspendResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::ResumeCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ResumeResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::ResumeResponse(
+ ::fidl::DecodedMessage<ResumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResumeResponse::PrimarySize,
+ ResumeResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::ResumeCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < ResumeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ResumeResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::ResumeResponse(
+ ::fidl::DecodedMessage<ResumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResumeResponse::PrimarySize,
+ ResumeResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::ResumeCompleterBase::Reply(::fidl::DecodedMessage<ResumeResponse> params) {
+ MockDevice::SetTransactionHeaderFor::ResumeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::MessageCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MessageResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ MessageResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::MessageResponse(
+ ::fidl::DecodedMessage<MessageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MessageResponse::PrimarySize,
+ MessageResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::MessageCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < MessageResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ MessageResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::MessageResponse(
+ ::fidl::DecodedMessage<MessageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MessageResponse::PrimarySize,
+ MessageResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::MessageCompleterBase::Reply(::fidl::DecodedMessage<MessageResponse> params) {
+ MockDevice::SetTransactionHeaderFor::MessageResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MockDevice::Interface::RxrpcCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RxrpcResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ RxrpcResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::RxrpcResponse(
+ ::fidl::DecodedMessage<RxrpcResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RxrpcResponse::PrimarySize,
+ RxrpcResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::RxrpcCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions) {
+ if (_buffer.capacity() < RxrpcResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RxrpcResponse _response = {};
+ MockDevice::SetTransactionHeaderFor::RxrpcResponse(
+ ::fidl::DecodedMessage<RxrpcResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RxrpcResponse::PrimarySize,
+ RxrpcResponse::PrimarySize)));
+ _response.actions = std::move(actions);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void MockDevice::Interface::RxrpcCompleterBase::Reply(::fidl::DecodedMessage<RxrpcResponse> params) {
+ MockDevice::SetTransactionHeaderFor::RxrpcResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void MockDevice::SetTransactionHeaderFor::BindRequest(const ::fidl::DecodedMessage<MockDevice::BindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::BindResponse(const ::fidl::DecodedMessage<MockDevice::BindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::ReleaseRequest(const ::fidl::DecodedMessage<MockDevice::ReleaseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Release_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::GetProtocolRequest(const ::fidl::DecodedMessage<MockDevice::GetProtocolRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_GetProtocol_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::GetProtocolResponse(const ::fidl::DecodedMessage<MockDevice::GetProtocolResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_GetProtocol_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::OpenRequest(const ::fidl::DecodedMessage<MockDevice::OpenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Open_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::OpenResponse(const ::fidl::DecodedMessage<MockDevice::OpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Open_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<MockDevice::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<MockDevice::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::UnbindRequest(const ::fidl::DecodedMessage<MockDevice::UnbindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Unbind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::UnbindResponse(const ::fidl::DecodedMessage<MockDevice::UnbindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Unbind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::ReadRequest(const ::fidl::DecodedMessage<MockDevice::ReadRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::ReadResponse(const ::fidl::DecodedMessage<MockDevice::ReadResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::WriteRequest(const ::fidl::DecodedMessage<MockDevice::WriteRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::WriteResponse(const ::fidl::DecodedMessage<MockDevice::WriteResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::GetSizeRequest(const ::fidl::DecodedMessage<MockDevice::GetSizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_GetSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::GetSizeResponse(const ::fidl::DecodedMessage<MockDevice::GetSizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_GetSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::SuspendRequest(const ::fidl::DecodedMessage<MockDevice::SuspendRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Suspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::SuspendResponse(const ::fidl::DecodedMessage<MockDevice::SuspendResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Suspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::ResumeRequest(const ::fidl::DecodedMessage<MockDevice::ResumeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Resume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::ResumeResponse(const ::fidl::DecodedMessage<MockDevice::ResumeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Resume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::MessageRequest(const ::fidl::DecodedMessage<MockDevice::MessageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Message_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::MessageResponse(const ::fidl::DecodedMessage<MockDevice::MessageResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Message_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::RxrpcRequest(const ::fidl::DecodedMessage<MockDevice::RxrpcRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Rxrpc_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MockDevice::SetTransactionHeaderFor::RxrpcResponse(const ::fidl::DecodedMessage<MockDevice::RxrpcResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_Rxrpc_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::AddDeviceDoneRequest(const ::fidl::DecodedMessage<MockDevice::AddDeviceDoneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_AddDeviceDone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::UnbindReplyDoneRequest(const ::fidl::DecodedMessage<MockDevice::UnbindReplyDoneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_UnbindReplyDone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MockDevice::SetTransactionHeaderFor::SuspendReplyDoneRequest(const ::fidl::DecodedMessage<MockDevice::SuspendReplyDoneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMockDevice_SuspendReplyDone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace mock
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/dev/test/mock-device/gen/llcpp/include/fuchsia/device/mock/llcpp/fidl.h b/zircon/system/dev/test/mock-device/gen/llcpp/include/fuchsia/device/mock/llcpp/fidl.h
new file mode 100644
index 0000000..70ab31b
--- /dev/null
+++ b/zircon/system/dev/test/mock-device/gen/llcpp/include/fuchsia/device/mock/llcpp/fidl.h
@@ -0,0 +1,2481 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace mock {
+
+struct AddDeviceAction;
+struct HookInvocation;
+struct UnbindReplyAction;
+struct SuspendReplyAction;
+struct Action;
+class MockDeviceThread;
+class MockDevice;
+
+extern "C" const fidl_type_t v1_fuchsia_device_mock_ActionTable;
+
+// What a hook should do.
+struct Action {
+ Action() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kReturnStatus = 1, // 0x1
+ kWrite = 2, // 0x2
+ kCreateThread = 3, // 0x3
+ kAsyncRemoveDevice = 4, // 0x4
+ kUnbindReply = 5, // 0x5
+ kAddDevice = 6, // 0x6
+ kSuspendReply = 7, // 0x7
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_return_status() const { return ordinal() == Ordinal::kReturnStatus; }
+
+ static Action WithReturnStatus(int32_t* val) {
+ Action result;
+ result.set_return_status(val);
+ return result;
+ }
+
+ // Return this status.
+ void set_return_status(int32_t* elem) {
+ ordinal_ = Ordinal::kReturnStatus;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Return this status.
+ int32_t& mutable_return_status() {
+ ZX_ASSERT(ordinal() == Ordinal::kReturnStatus);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& return_status() const {
+ ZX_ASSERT(ordinal() == Ordinal::kReturnStatus);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+
+ bool is_write() const { return ordinal() == Ordinal::kWrite; }
+
+ static Action WithWrite(::fidl::VectorView<uint8_t>* val) {
+ Action result;
+ result.set_write(val);
+ return result;
+ }
+
+ // Write these bytes to the buffer associated with the hook.
+ void set_write(::fidl::VectorView<uint8_t>* elem) {
+ ordinal_ = Ordinal::kWrite;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Write these bytes to the buffer associated with the hook.
+ ::fidl::VectorView<uint8_t>& mutable_write() {
+ ZX_ASSERT(ordinal() == Ordinal::kWrite);
+ return *static_cast<::fidl::VectorView<uint8_t>*>(envelope_.data);
+ }
+ const ::fidl::VectorView<uint8_t>& write() const {
+ ZX_ASSERT(ordinal() == Ordinal::kWrite);
+ return *static_cast<::fidl::VectorView<uint8_t>*>(envelope_.data);
+ }
+
+ bool is_create_thread() const { return ordinal() == Ordinal::kCreateThread; }
+
+ static Action WithCreateThread(::zx::channel* val) {
+ Action result;
+ result.set_create_thread(val);
+ return result;
+ }
+
+ // Create a new thread with a processing loop.
+ void set_create_thread(::zx::channel* elem) {
+ ordinal_ = Ordinal::kCreateThread;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Create a new thread with a processing loop.
+ ::zx::channel& mutable_create_thread() {
+ ZX_ASSERT(ordinal() == Ordinal::kCreateThread);
+ return *static_cast<::zx::channel*>(envelope_.data);
+ }
+ const ::zx::channel& create_thread() const {
+ ZX_ASSERT(ordinal() == Ordinal::kCreateThread);
+ return *static_cast<::zx::channel*>(envelope_.data);
+ }
+
+ bool is_async_remove_device() const { return ordinal() == Ordinal::kAsyncRemoveDevice; }
+
+ static Action WithAsyncRemoveDevice(bool* val) {
+ Action result;
+ result.set_async_remove_device(val);
+ return result;
+ }
+
+ // Invoke device_async_remove() on our device.
+ void set_async_remove_device(bool* elem) {
+ ordinal_ = Ordinal::kAsyncRemoveDevice;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Invoke device_async_remove() on our device.
+ bool& mutable_async_remove_device() {
+ ZX_ASSERT(ordinal() == Ordinal::kAsyncRemoveDevice);
+ return *static_cast<bool*>(envelope_.data);
+ }
+ const bool& async_remove_device() const {
+ ZX_ASSERT(ordinal() == Ordinal::kAsyncRemoveDevice);
+ return *static_cast<bool*>(envelope_.data);
+ }
+
+ bool is_unbind_reply() const { return ordinal() == Ordinal::kUnbindReply; }
+
+ static Action WithUnbindReply(::llcpp::fuchsia::device::mock::UnbindReplyAction* val) {
+ Action result;
+ result.set_unbind_reply(val);
+ return result;
+ }
+
+ // Signal that the unbind has completed.
+ void set_unbind_reply(::llcpp::fuchsia::device::mock::UnbindReplyAction* elem) {
+ ordinal_ = Ordinal::kUnbindReply;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Signal that the unbind has completed.
+ ::llcpp::fuchsia::device::mock::UnbindReplyAction& mutable_unbind_reply() {
+ ZX_ASSERT(ordinal() == Ordinal::kUnbindReply);
+ return *static_cast<::llcpp::fuchsia::device::mock::UnbindReplyAction*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::mock::UnbindReplyAction& unbind_reply() const {
+ ZX_ASSERT(ordinal() == Ordinal::kUnbindReply);
+ return *static_cast<::llcpp::fuchsia::device::mock::UnbindReplyAction*>(envelope_.data);
+ }
+
+ bool is_add_device() const { return ordinal() == Ordinal::kAddDevice; }
+
+ static Action WithAddDevice(::llcpp::fuchsia::device::mock::AddDeviceAction* val) {
+ Action result;
+ result.set_add_device(val);
+ return result;
+ }
+
+ // Create a new child device
+ void set_add_device(::llcpp::fuchsia::device::mock::AddDeviceAction* elem) {
+ ordinal_ = Ordinal::kAddDevice;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Create a new child device
+ ::llcpp::fuchsia::device::mock::AddDeviceAction& mutable_add_device() {
+ ZX_ASSERT(ordinal() == Ordinal::kAddDevice);
+ return *static_cast<::llcpp::fuchsia::device::mock::AddDeviceAction*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::mock::AddDeviceAction& add_device() const {
+ ZX_ASSERT(ordinal() == Ordinal::kAddDevice);
+ return *static_cast<::llcpp::fuchsia::device::mock::AddDeviceAction*>(envelope_.data);
+ }
+
+ bool is_suspend_reply() const { return ordinal() == Ordinal::kSuspendReply; }
+
+ static Action WithSuspendReply(::llcpp::fuchsia::device::mock::SuspendReplyAction* val) {
+ Action result;
+ result.set_suspend_reply(val);
+ return result;
+ }
+
+ // Signal that the suspend has completed.
+ void set_suspend_reply(::llcpp::fuchsia::device::mock::SuspendReplyAction* elem) {
+ ordinal_ = Ordinal::kSuspendReply;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Signal that the suspend has completed.
+ ::llcpp::fuchsia::device::mock::SuspendReplyAction& mutable_suspend_reply() {
+ ZX_ASSERT(ordinal() == Ordinal::kSuspendReply);
+ return *static_cast<::llcpp::fuchsia::device::mock::SuspendReplyAction*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::mock::SuspendReplyAction& suspend_reply() const {
+ ZX_ASSERT(ordinal() == Ordinal::kSuspendReply);
+ return *static_cast<::llcpp::fuchsia::device::mock::SuspendReplyAction*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_ActionTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16400;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kReturnStatus = 1, // 0x1
+ kWrite = 2, // 0x2
+ kCreateThread = 3, // 0x3
+ kAsyncRemoveDevice = 4, // 0x4
+ kUnbindReply = 5, // 0x5
+ kAddDevice = 6, // 0x6
+ kSuspendReply = 7, // 0x7
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_mock_AddDeviceActionTable;
+
+// Request to add a new child device
+struct AddDeviceAction {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_AddDeviceActionTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 288;
+ static constexpr bool HasPointer = true;
+
+ // Value that will be echoed back in the completion message
+ uint64_t action_id = {};
+
+ // If true, will let the device go through the bind protocol.
+ // Otherwise, will just create another mock device and skip binding.
+ bool do_bind = {};
+
+ // If creating a mock device, the service the new device will listen to.
+ ::zx::channel controller = {};
+
+ // The name that should be given to the new device. Used by devfs and
+ // debug messages.
+ ::fidl::StringView name = {};
+
+ // The properties to attach the newly created device
+ ::fidl::VectorView<uint64_t> properties = {};
+
+ // The expected return status from device_add()
+ int32_t expect_status = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_mock_HookInvocationTable;
+
+// A record of the invocation of a hook
+struct HookInvocation {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_HookInvocationTable;
+ 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;
+
+ // Process that the hook was invoked in
+ uint64_t process_koid = {};
+
+ // Thread that the hook was invoked on
+ uint64_t thread_koid = {};
+
+ // An opaque identifier identifying a specific device
+ uint64_t device_id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_mock_UnbindReplyActionTable;
+
+// Marker struct for unbind reply action
+struct UnbindReplyAction {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_UnbindReplyActionTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Value that will be echoed back in the completion message
+ uint64_t action_id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_mock_SuspendReplyActionTable;
+
+// Marker struct for suspend reply action
+struct SuspendReplyAction {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_SuspendReplyActionTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Value that will be echoed back in the completion message
+ uint64_t action_id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadPerformActionsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadPerformActionsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadAddDeviceDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadAddDeviceDoneEventTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadUnbindReplyDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadUnbindReplyDoneEventTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadSuspendReplyDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceThreadSuspendReplyDoneEventTable;
+
+// Interface for requesting a mock device thread do something. The mock device implements
+// this interface. Closing the interface causes the thread to exit.
+class MockDeviceThread final {
+ MockDeviceThread() = delete;
+ public:
+
+ struct PerformActionsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceThreadPerformActionsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ struct AddDeviceDoneResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t action_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceThreadAddDeviceDoneEventTable;
+ 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 UnbindReplyDoneResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t action_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceThreadUnbindReplyDoneEventTable;
+ 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 SuspendReplyDoneResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t action_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceThreadSuspendReplyDoneEventTable;
+ 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 EventHandlers {
+ // Notification that the requested action was done
+ fit::callback<zx_status_t(uint64_t action_id)> add_device_done;
+
+ fit::callback<zx_status_t(uint64_t action_id)> unbind_reply_done;
+
+ fit::callback<zx_status_t(uint64_t action_id)> suspend_reply_done;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class PerformActions_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ PerformActions_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ ~PerformActions_Impl() = default;
+ PerformActions_Impl(PerformActions_Impl&& other) = default;
+ PerformActions_Impl& operator=(PerformActions_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using PerformActions = PerformActions_Impl;
+ };
+
+ // 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:
+ class PerformActions_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ PerformActions_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ ~PerformActions_Impl() = default;
+ PerformActions_Impl(PerformActions_Impl&& other) = default;
+ PerformActions_Impl& operator=(PerformActions_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using PerformActions = PerformActions_Impl;
+ };
+
+ 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_; }
+
+ // Perform the actions in the given list. Threads may not create other threads.
+ // Request is heap-allocated.
+ ResultOf::PerformActions PerformActions(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+
+ // Perform the actions in the given list. Threads may not create other threads.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::PerformActions PerformActions(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Perform the actions in the given list. Threads may not create other threads.
+ // Request is heap-allocated.
+ static ResultOf::PerformActions PerformActions(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+
+ // Perform the actions in the given list. Threads may not create other threads.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::PerformActions PerformActions(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Perform the actions in the given list. Threads may not create other threads.
+ static ::fidl::internal::StatusAndError PerformActions(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PerformActionsRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = MockDeviceThread;
+ using _Base = ::fidl::CompleterBase;
+
+ using PerformActionsCompleter = ::fidl::Completer<>;
+
+ virtual void PerformActions(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions, PerformActionsCompleter::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);
+ }
+
+ // Notification that the requested action was done
+ static zx_status_t SendAddDeviceDoneEvent(::zx::unowned_channel _chan, uint64_t action_id);
+
+ // Notification that the requested action was done
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendAddDeviceDoneEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t action_id);
+
+ // Notification that the requested action was done
+ // Messages are encoded in-place.
+ static zx_status_t SendAddDeviceDoneEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<AddDeviceDoneResponse> params);
+
+ static zx_status_t SendUnbindReplyDoneEvent(::zx::unowned_channel _chan, uint64_t action_id);
+
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendUnbindReplyDoneEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t action_id);
+
+ // Messages are encoded in-place.
+ static zx_status_t SendUnbindReplyDoneEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<UnbindReplyDoneResponse> params);
+
+ static zx_status_t SendSuspendReplyDoneEvent(::zx::unowned_channel _chan, uint64_t action_id);
+
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendSuspendReplyDoneEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t action_id);
+
+ // Messages are encoded in-place.
+ static zx_status_t SendSuspendReplyDoneEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<SuspendReplyDoneResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void PerformActionsRequest(const ::fidl::DecodedMessage<MockDeviceThread::PerformActionsRequest>& _msg);
+ static void AddDeviceDoneResponse(const ::fidl::DecodedMessage<MockDeviceThread::AddDeviceDoneResponse>& _msg);
+ static void UnbindReplyDoneResponse(const ::fidl::DecodedMessage<MockDeviceThread::UnbindReplyDoneResponse>& _msg);
+ static void SuspendReplyDoneResponse(const ::fidl::DecodedMessage<MockDeviceThread::SuspendReplyDoneResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceBindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceReleaseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceReleaseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceGetProtocolRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceGetProtocolResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceOpenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceUnbindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceUnbindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceReadResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceWriteResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceGetSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceGetSizeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceSuspendResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceResumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceResumeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceMessageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceMessageResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceRxrpcRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceRxrpcResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceAddDeviceDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceAddDeviceDoneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceUnbindReplyDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceUnbindReplyDoneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceSuspendReplyDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_mock_MockDeviceSuspendReplyDoneResponseTable;
+
+// Interface for controlling a mock device. The test suite will implement this interface.
+// Any method that returns a list of actions is interpreted as requesting the corresponding hook
+// to perform that list of actions in order.
+class MockDevice final {
+ MockDevice() = delete;
+ public:
+
+ struct BindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceBindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct BindRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceBindRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = BindResponse;
+ };
+
+ struct ReleaseRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceReleaseRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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;
+ };
+
+ struct GetProtocolResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceGetProtocolResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetProtocolRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+ uint32_t protocol_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceGetProtocolRequestTable;
+ 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 = GetProtocolResponse;
+ };
+
+ struct OpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceOpenResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct OpenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceOpenRequestTable;
+ 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 = OpenResponse;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceCloseResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct CloseRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceCloseRequestTable;
+ 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 = CloseResponse;
+ };
+
+ struct UnbindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceUnbindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UnbindRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceUnbindRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = UnbindResponse;
+ };
+
+ struct ReadResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceReadResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ReadRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+ uint64_t count;
+ uint64_t off;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceReadRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 56;
+ 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 = ReadResponse;
+ };
+
+ struct WriteResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceWriteResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct WriteRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+ ::fidl::VectorView<uint8_t> buffer;
+ uint64_t off;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceWriteRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 64;
+ static constexpr uint32_t MaxOutOfLine = 16384;
+ static constexpr uint32_t AltPrimarySize = 64;
+ static constexpr uint32_t AltMaxOutOfLine = 16384;
+ 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 = WriteResponse;
+ };
+
+ struct GetSizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceGetSizeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetSizeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceGetSizeRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = GetSizeResponse;
+ };
+
+ struct SuspendResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceSuspendResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SuspendRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+ uint8_t requested_state;
+ bool enable_wake;
+ uint8_t suspend_reason;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceSuspendRequestTable;
+ 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 = SuspendResponse;
+ };
+
+ struct ResumeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceResumeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ResumeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceResumeRequestTable;
+ 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 = ResumeResponse;
+ };
+
+ struct MessageResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceMessageResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct MessageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceMessageRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = MessageResponse;
+ };
+
+ struct RxrpcResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceRxrpcResponseTable;
+ static constexpr uint32_t MaxNumHandles = 10;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 164240;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RxrpcRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::mock::HookInvocation record;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceRxrpcRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = RxrpcResponse;
+ };
+
+ struct AddDeviceDoneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t action_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceAddDeviceDoneRequestTable;
+ 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;
+ };
+
+ struct UnbindReplyDoneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t action_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceUnbindReplyDoneRequestTable;
+ 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;
+ };
+
+ struct SuspendReplyDoneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t action_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_mock_MockDeviceSuspendReplyDoneRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Bind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Release_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Release_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+ ~Release_Impl() = default;
+ Release_Impl(Release_Impl&& other) = default;
+ Release_Impl& operator=(Release_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class GetProtocol_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetProtocol_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id);
+ ~GetProtocol_Impl() = default;
+ GetProtocol_Impl(GetProtocol_Impl&& other) = default;
+ GetProtocol_Impl& operator=(GetProtocol_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 Open_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_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 Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Unbind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Unbind_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+ ~Unbind_Impl() = default;
+ Unbind_Impl(Unbind_Impl&& other) = default;
+ Unbind_Impl& operator=(Unbind_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 Read_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 Write_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 GetSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+ ~GetSize_Impl() = default;
+ GetSize_Impl(GetSize_Impl&& other) = default;
+ GetSize_Impl& operator=(GetSize_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 Suspend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Suspend_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason);
+ ~Suspend_Impl() = default;
+ Suspend_Impl(Suspend_Impl&& other) = default;
+ Suspend_Impl& operator=(Suspend_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 Resume_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Resume_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+ ~Resume_Impl() = default;
+ Resume_Impl(Resume_Impl&& other) = default;
+ Resume_Impl& operator=(Resume_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 Message_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Message_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+ ~Message_Impl() = default;
+ Message_Impl(Message_Impl&& other) = default;
+ Message_Impl& operator=(Message_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 Rxrpc_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rxrpc_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+ ~Rxrpc_Impl() = default;
+ Rxrpc_Impl(Rxrpc_Impl&& other) = default;
+ Rxrpc_Impl& operator=(Rxrpc_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class AddDeviceDone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddDeviceDone_Impl(::zx::unowned_channel _client_end, uint64_t action_id);
+ ~AddDeviceDone_Impl() = default;
+ AddDeviceDone_Impl(AddDeviceDone_Impl&& other) = default;
+ AddDeviceDone_Impl& operator=(AddDeviceDone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class UnbindReplyDone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ UnbindReplyDone_Impl(::zx::unowned_channel _client_end, uint64_t action_id);
+ ~UnbindReplyDone_Impl() = default;
+ UnbindReplyDone_Impl(UnbindReplyDone_Impl&& other) = default;
+ UnbindReplyDone_Impl& operator=(UnbindReplyDone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SuspendReplyDone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SuspendReplyDone_Impl(::zx::unowned_channel _client_end, uint64_t action_id);
+ ~SuspendReplyDone_Impl() = default;
+ SuspendReplyDone_Impl(SuspendReplyDone_Impl&& other) = default;
+ SuspendReplyDone_Impl& operator=(SuspendReplyDone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Bind = Bind_Impl<BindResponse>;
+ using Release = Release_Impl;
+ using GetProtocol = GetProtocol_Impl<GetProtocolResponse>;
+ using Open = Open_Impl<OpenResponse>;
+ using Close = Close_Impl<CloseResponse>;
+ using Unbind = Unbind_Impl<UnbindResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using GetSize = GetSize_Impl<GetSizeResponse>;
+ using Suspend = Suspend_Impl<SuspendResponse>;
+ using Resume = Resume_Impl<ResumeResponse>;
+ using Message = Message_Impl<MessageResponse>;
+ using Rxrpc = Rxrpc_Impl<RxrpcResponse>;
+ using AddDeviceDone = AddDeviceDone_Impl;
+ using UnbindReplyDone = UnbindReplyDone_Impl;
+ using SuspendReplyDone = SuspendReplyDone_Impl;
+ };
+
+ // 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 Bind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Release_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Release_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record);
+ ~Release_Impl() = default;
+ Release_Impl(Release_Impl&& other) = default;
+ Release_Impl& operator=(Release_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class GetProtocol_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetProtocol_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id, ::fidl::BytePart _response_buffer);
+ ~GetProtocol_Impl() = default;
+ GetProtocol_Impl(GetProtocol_Impl&& other) = default;
+ GetProtocol_Impl& operator=(GetProtocol_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 Open_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_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 Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Unbind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Unbind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+ ~Unbind_Impl() = default;
+ Unbind_Impl(Unbind_Impl&& other) = default;
+ Unbind_Impl& operator=(Unbind_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 Read_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off, ::fidl::BytePart _response_buffer);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 Write_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off, ::fidl::BytePart _response_buffer);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 GetSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+ ~GetSize_Impl() = default;
+ GetSize_Impl(GetSize_Impl&& other) = default;
+ GetSize_Impl& operator=(GetSize_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 Suspend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason, ::fidl::BytePart _response_buffer);
+ ~Suspend_Impl() = default;
+ Suspend_Impl(Suspend_Impl&& other) = default;
+ Suspend_Impl& operator=(Suspend_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 Resume_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Resume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~Resume_Impl() = default;
+ Resume_Impl(Resume_Impl&& other) = default;
+ Resume_Impl& operator=(Resume_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 Message_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Message_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+ ~Message_Impl() = default;
+ Message_Impl(Message_Impl&& other) = default;
+ Message_Impl& operator=(Message_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 Rxrpc_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rxrpc_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+ ~Rxrpc_Impl() = default;
+ Rxrpc_Impl(Rxrpc_Impl&& other) = default;
+ Rxrpc_Impl& operator=(Rxrpc_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class AddDeviceDone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddDeviceDone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id);
+ ~AddDeviceDone_Impl() = default;
+ AddDeviceDone_Impl(AddDeviceDone_Impl&& other) = default;
+ AddDeviceDone_Impl& operator=(AddDeviceDone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class UnbindReplyDone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ UnbindReplyDone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id);
+ ~UnbindReplyDone_Impl() = default;
+ UnbindReplyDone_Impl(UnbindReplyDone_Impl&& other) = default;
+ UnbindReplyDone_Impl& operator=(UnbindReplyDone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SuspendReplyDone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SuspendReplyDone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id);
+ ~SuspendReplyDone_Impl() = default;
+ SuspendReplyDone_Impl(SuspendReplyDone_Impl&& other) = default;
+ SuspendReplyDone_Impl& operator=(SuspendReplyDone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Bind = Bind_Impl<BindResponse>;
+ using Release = Release_Impl;
+ using GetProtocol = GetProtocol_Impl<GetProtocolResponse>;
+ using Open = Open_Impl<OpenResponse>;
+ using Close = Close_Impl<CloseResponse>;
+ using Unbind = Unbind_Impl<UnbindResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using GetSize = GetSize_Impl<GetSizeResponse>;
+ using Suspend = Suspend_Impl<SuspendResponse>;
+ using Resume = Resume_Impl<ResumeResponse>;
+ using Message = Message_Impl<MessageResponse>;
+ using Rxrpc = Rxrpc_Impl<RxrpcResponse>;
+ using AddDeviceDone = AddDeviceDone_Impl;
+ using UnbindReplyDone = UnbindReplyDone_Impl;
+ using SuspendReplyDone = SuspendReplyDone_Impl;
+ };
+
+ 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_; }
+
+ // `record.device_id` corresponds to the parent here.
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Bind Bind(::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // `record.device_id` corresponds to the parent here.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Bind Bind(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Release Release(::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Release Release(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetProtocol GetProtocol(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetProtocol GetProtocol(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Open Open(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Open Open(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Close Close(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Unbind Unbind(::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Unbind Unbind(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Allocates 56 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Read Read(::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Read Read(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off, ::fidl::BytePart _response_buffer);
+
+ // Request is heap-allocated. Response is heap-allocated.
+ ResultOf::Write Write(::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Write Write(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetSize GetSize(::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSize GetSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Suspend Suspend(::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Suspend Suspend(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Resume Resume(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Resume Resume(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Message Message(::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Message Message(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Rxrpc Rxrpc(::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rxrpc Rxrpc(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Notification that the requested action was done
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AddDeviceDone AddDeviceDone(uint64_t action_id);
+
+ // Notification that the requested action was done
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddDeviceDone AddDeviceDone(::fidl::BytePart _request_buffer, uint64_t action_id);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UnbindReplyDone UnbindReplyDone(uint64_t action_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UnbindReplyDone UnbindReplyDone(::fidl::BytePart _request_buffer, uint64_t action_id);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SuspendReplyDone SuspendReplyDone(uint64_t action_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SuspendReplyDone SuspendReplyDone(::fidl::BytePart _request_buffer, uint64_t action_id);
+
+ 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:
+
+ // `record.device_id` corresponds to the parent here.
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Bind Bind(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // `record.device_id` corresponds to the parent here.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Release Release(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Release Release(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetProtocol GetProtocol(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetProtocol GetProtocol(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Open Open(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Open Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Unbind Unbind(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Unbind Unbind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Allocates 56 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Read Read(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Read Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off, ::fidl::BytePart _response_buffer);
+
+ // Request is heap-allocated. Response is heap-allocated.
+ static ResultOf::Write Write(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetSize GetSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSize GetSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Suspend Suspend(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Suspend Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Resume Resume(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Resume Resume(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Message Message(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Message Message(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Rxrpc Rxrpc(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::mock::HookInvocation record);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rxrpc Rxrpc(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::BytePart _response_buffer);
+
+ // Notification that the requested action was done
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AddDeviceDone AddDeviceDone(::zx::unowned_channel _client_end, uint64_t action_id);
+
+ // Notification that the requested action was done
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddDeviceDone AddDeviceDone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UnbindReplyDone UnbindReplyDone(::zx::unowned_channel _client_end, uint64_t action_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UnbindReplyDone UnbindReplyDone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SuspendReplyDone SuspendReplyDone(::zx::unowned_channel _client_end, uint64_t action_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SuspendReplyDone SuspendReplyDone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t action_id);
+
+ };
+
+ // 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:
+
+ // `record.device_id` corresponds to the parent here.
+ static ::fidl::DecodeResult<BindResponse> Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::internal::StatusAndError Release(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseRequest> params);
+
+ static ::fidl::DecodeResult<GetProtocolResponse> GetProtocol(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetProtocolRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<OpenResponse> Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloseRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<UnbindResponse> Unbind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnbindRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ReadResponse> Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<WriteResponse> Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetSizeResponse> GetSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSizeRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<SuspendResponse> Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ResumeResponse> Resume(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<MessageResponse> Message(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MessageRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<RxrpcResponse> Rxrpc(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RxrpcRequest> params, ::fidl::BytePart response_buffer);
+
+ // Notification that the requested action was done
+ static ::fidl::internal::StatusAndError AddDeviceDone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceDoneRequest> params);
+
+ static ::fidl::internal::StatusAndError UnbindReplyDone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnbindReplyDoneRequest> params);
+
+ static ::fidl::internal::StatusAndError SuspendReplyDone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendReplyDoneRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = MockDevice;
+ using _Base = ::fidl::CompleterBase;
+
+ class BindCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<BindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BindCompleter = ::fidl::Completer<BindCompleterBase>;
+
+ virtual void Bind(::llcpp::fuchsia::device::mock::HookInvocation record, BindCompleter::Sync _completer) = 0;
+
+ using ReleaseCompleter = ::fidl::Completer<>;
+
+ virtual void Release(::llcpp::fuchsia::device::mock::HookInvocation record, ReleaseCompleter::Sync _completer) = 0;
+
+ class GetProtocolCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<GetProtocolResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetProtocolCompleter = ::fidl::Completer<GetProtocolCompleterBase>;
+
+ virtual void GetProtocol(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t protocol_id, GetProtocolCompleter::Sync _completer) = 0;
+
+ class OpenCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<OpenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using OpenCompleter = ::fidl::Completer<OpenCompleterBase>;
+
+ virtual void Open(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, OpenCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, CloseCompleter::Sync _completer) = 0;
+
+ class UnbindCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<UnbindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnbindCompleter = ::fidl::Completer<UnbindCompleterBase>;
+
+ virtual void Unbind(::llcpp::fuchsia::device::mock::HookInvocation record, UnbindCompleter::Sync _completer) = 0;
+
+ class ReadCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<ReadResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadCompleter = ::fidl::Completer<ReadCompleterBase>;
+
+ virtual void Read(::llcpp::fuchsia::device::mock::HookInvocation record, uint64_t count, uint64_t off, ReadCompleter::Sync _completer) = 0;
+
+ class WriteCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<WriteResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteCompleter = ::fidl::Completer<WriteCompleterBase>;
+
+ virtual void Write(::llcpp::fuchsia::device::mock::HookInvocation record, ::fidl::VectorView<uint8_t> buffer, uint64_t off, WriteCompleter::Sync _completer) = 0;
+
+ class GetSizeCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<GetSizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSizeCompleter = ::fidl::Completer<GetSizeCompleterBase>;
+
+ virtual void GetSize(::llcpp::fuchsia::device::mock::HookInvocation record, GetSizeCompleter::Sync _completer) = 0;
+
+ class SuspendCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<SuspendResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SuspendCompleter = ::fidl::Completer<SuspendCompleterBase>;
+
+ virtual void Suspend(::llcpp::fuchsia::device::mock::HookInvocation record, uint8_t requested_state, bool enable_wake, uint8_t suspend_reason, SuspendCompleter::Sync _completer) = 0;
+
+ class ResumeCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<ResumeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ResumeCompleter = ::fidl::Completer<ResumeCompleterBase>;
+
+ virtual void Resume(::llcpp::fuchsia::device::mock::HookInvocation record, uint32_t flags, ResumeCompleter::Sync _completer) = 0;
+
+ class MessageCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<MessageResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using MessageCompleter = ::fidl::Completer<MessageCompleterBase>;
+
+ virtual void Message(::llcpp::fuchsia::device::mock::HookInvocation record, MessageCompleter::Sync _completer) = 0;
+
+ class RxrpcCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::device::mock::Action> actions);
+ void Reply(::fidl::DecodedMessage<RxrpcResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RxrpcCompleter = ::fidl::Completer<RxrpcCompleterBase>;
+
+ virtual void Rxrpc(::llcpp::fuchsia::device::mock::HookInvocation record, RxrpcCompleter::Sync _completer) = 0;
+
+ using AddDeviceDoneCompleter = ::fidl::Completer<>;
+
+ virtual void AddDeviceDone(uint64_t action_id, AddDeviceDoneCompleter::Sync _completer) = 0;
+
+ using UnbindReplyDoneCompleter = ::fidl::Completer<>;
+
+ virtual void UnbindReplyDone(uint64_t action_id, UnbindReplyDoneCompleter::Sync _completer) = 0;
+
+ using SuspendReplyDoneCompleter = ::fidl::Completer<>;
+
+ virtual void SuspendReplyDone(uint64_t action_id, SuspendReplyDoneCompleter::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 BindRequest(const ::fidl::DecodedMessage<MockDevice::BindRequest>& _msg);
+ static void BindResponse(const ::fidl::DecodedMessage<MockDevice::BindResponse>& _msg);
+ static void ReleaseRequest(const ::fidl::DecodedMessage<MockDevice::ReleaseRequest>& _msg);
+ static void GetProtocolRequest(const ::fidl::DecodedMessage<MockDevice::GetProtocolRequest>& _msg);
+ static void GetProtocolResponse(const ::fidl::DecodedMessage<MockDevice::GetProtocolResponse>& _msg);
+ static void OpenRequest(const ::fidl::DecodedMessage<MockDevice::OpenRequest>& _msg);
+ static void OpenResponse(const ::fidl::DecodedMessage<MockDevice::OpenResponse>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<MockDevice::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<MockDevice::CloseResponse>& _msg);
+ static void UnbindRequest(const ::fidl::DecodedMessage<MockDevice::UnbindRequest>& _msg);
+ static void UnbindResponse(const ::fidl::DecodedMessage<MockDevice::UnbindResponse>& _msg);
+ static void ReadRequest(const ::fidl::DecodedMessage<MockDevice::ReadRequest>& _msg);
+ static void ReadResponse(const ::fidl::DecodedMessage<MockDevice::ReadResponse>& _msg);
+ static void WriteRequest(const ::fidl::DecodedMessage<MockDevice::WriteRequest>& _msg);
+ static void WriteResponse(const ::fidl::DecodedMessage<MockDevice::WriteResponse>& _msg);
+ static void GetSizeRequest(const ::fidl::DecodedMessage<MockDevice::GetSizeRequest>& _msg);
+ static void GetSizeResponse(const ::fidl::DecodedMessage<MockDevice::GetSizeResponse>& _msg);
+ static void SuspendRequest(const ::fidl::DecodedMessage<MockDevice::SuspendRequest>& _msg);
+ static void SuspendResponse(const ::fidl::DecodedMessage<MockDevice::SuspendResponse>& _msg);
+ static void ResumeRequest(const ::fidl::DecodedMessage<MockDevice::ResumeRequest>& _msg);
+ static void ResumeResponse(const ::fidl::DecodedMessage<MockDevice::ResumeResponse>& _msg);
+ static void MessageRequest(const ::fidl::DecodedMessage<MockDevice::MessageRequest>& _msg);
+ static void MessageResponse(const ::fidl::DecodedMessage<MockDevice::MessageResponse>& _msg);
+ static void RxrpcRequest(const ::fidl::DecodedMessage<MockDevice::RxrpcRequest>& _msg);
+ static void RxrpcResponse(const ::fidl::DecodedMessage<MockDevice::RxrpcResponse>& _msg);
+ static void AddDeviceDoneRequest(const ::fidl::DecodedMessage<MockDevice::AddDeviceDoneRequest>& _msg);
+ static void UnbindReplyDoneRequest(const ::fidl::DecodedMessage<MockDevice::UnbindReplyDoneRequest>& _msg);
+ static void SuspendReplyDoneRequest(const ::fidl::DecodedMessage<MockDevice::SuspendReplyDoneRequest>& _msg);
+ };
+};
+
+constexpr uint32_t MAX_WRITE_BYTES = 16384u;
+
+constexpr uint32_t MAX_PROPERTIES_LEN = 32u;
+
+constexpr uint32_t MAX_NAME_LEN = 32u;
+
+constexpr uint32_t MAX_ACTIONS = 10u;
+
+} // namespace mock
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::AddDeviceAction> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::mock::AddDeviceAction>);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::AddDeviceAction, action_id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::AddDeviceAction, do_bind) == 8);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::AddDeviceAction, controller) == 12);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::AddDeviceAction, name) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::AddDeviceAction, properties) == 32);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::AddDeviceAction, expect_status) == 48);
+static_assert(sizeof(::llcpp::fuchsia::device::mock::AddDeviceAction) == ::llcpp::fuchsia::device::mock::AddDeviceAction::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::HookInvocation> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::mock::HookInvocation>);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::HookInvocation, process_koid) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::HookInvocation, thread_koid) == 8);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::HookInvocation, device_id) == 16);
+static_assert(sizeof(::llcpp::fuchsia::device::mock::HookInvocation) == ::llcpp::fuchsia::device::mock::HookInvocation::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::UnbindReplyAction> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::mock::UnbindReplyAction>);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::UnbindReplyAction, action_id) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::mock::UnbindReplyAction) == ::llcpp::fuchsia::device::mock::UnbindReplyAction::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::SuspendReplyAction> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::mock::SuspendReplyAction>);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::SuspendReplyAction, action_id) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::mock::SuspendReplyAction) == ::llcpp::fuchsia::device::mock::SuspendReplyAction::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::Action> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::mock::Action>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDeviceThread::PerformActionsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDeviceThread::PerformActionsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDeviceThread::PerformActionsRequest)
+ == ::llcpp::fuchsia::device::mock::MockDeviceThread::PerformActionsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDeviceThread::PerformActionsRequest, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDeviceThread::AddDeviceDoneResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDeviceThread::AddDeviceDoneResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDeviceThread::AddDeviceDoneResponse)
+ == ::llcpp::fuchsia::device::mock::MockDeviceThread::AddDeviceDoneResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDeviceThread::AddDeviceDoneResponse, action_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDeviceThread::UnbindReplyDoneResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDeviceThread::UnbindReplyDoneResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDeviceThread::UnbindReplyDoneResponse)
+ == ::llcpp::fuchsia::device::mock::MockDeviceThread::UnbindReplyDoneResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDeviceThread::UnbindReplyDoneResponse, action_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDeviceThread::SuspendReplyDoneResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDeviceThread::SuspendReplyDoneResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDeviceThread::SuspendReplyDoneResponse)
+ == ::llcpp::fuchsia::device::mock::MockDeviceThread::SuspendReplyDoneResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDeviceThread::SuspendReplyDoneResponse, action_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::BindRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::BindRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::BindRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::BindRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::BindRequest, record) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::BindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::BindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::BindResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::BindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::BindResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::ReleaseRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::ReleaseRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::ReleaseRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::ReleaseRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::ReleaseRequest, record) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::GetProtocolRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::GetProtocolRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::GetProtocolRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::GetProtocolRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::GetProtocolRequest, record) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::GetProtocolRequest, protocol_id) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::GetProtocolResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::GetProtocolResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::GetProtocolResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::GetProtocolResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::GetProtocolResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::OpenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::OpenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::OpenRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::OpenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::OpenRequest, record) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::OpenRequest, flags) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::OpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::OpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::OpenResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::OpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::OpenResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::CloseRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::CloseRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::CloseRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::CloseRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::CloseRequest, record) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::CloseRequest, flags) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::CloseResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::CloseResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::UnbindRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::UnbindRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::UnbindRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::UnbindRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::UnbindRequest, record) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::UnbindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::UnbindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::UnbindResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::UnbindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::UnbindResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::ReadRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::ReadRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::ReadRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::ReadRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::ReadRequest, record) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::ReadRequest, count) == 40);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::ReadRequest, off) == 48);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::ReadResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::ReadResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::ReadResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::ReadResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::ReadResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::WriteRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::WriteRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::WriteRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::WriteRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::WriteRequest, record) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::WriteRequest, buffer) == 40);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::WriteRequest, off) == 56);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::WriteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::WriteResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::WriteResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::WriteResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::WriteResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::GetSizeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::GetSizeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::GetSizeRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::GetSizeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::GetSizeRequest, record) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::GetSizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::GetSizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::GetSizeResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::GetSizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::GetSizeResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::SuspendRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::SuspendRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::SuspendRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::SuspendRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::SuspendRequest, record) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::SuspendRequest, requested_state) == 40);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::SuspendRequest, enable_wake) == 41);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::SuspendRequest, suspend_reason) == 42);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::SuspendResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::SuspendResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::SuspendResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::SuspendResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::SuspendResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::ResumeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::ResumeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::ResumeRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::ResumeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::ResumeRequest, record) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::ResumeRequest, flags) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::ResumeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::ResumeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::ResumeResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::ResumeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::ResumeResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::MessageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::MessageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::MessageRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::MessageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::MessageRequest, record) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::MessageResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::MessageResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::MessageResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::MessageResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::MessageResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::RxrpcRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::RxrpcRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::RxrpcRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::RxrpcRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::RxrpcRequest, record) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::RxrpcResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::RxrpcResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::RxrpcResponse)
+ == ::llcpp::fuchsia::device::mock::MockDevice::RxrpcResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::RxrpcResponse, actions) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::AddDeviceDoneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::AddDeviceDoneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::AddDeviceDoneRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::AddDeviceDoneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::AddDeviceDoneRequest, action_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::UnbindReplyDoneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::UnbindReplyDoneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::UnbindReplyDoneRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::UnbindReplyDoneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::UnbindReplyDoneRequest, action_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::mock::MockDevice::SuspendReplyDoneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::mock::MockDevice::SuspendReplyDoneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::mock::MockDevice::SuspendReplyDoneRequest)
+ == ::llcpp::fuchsia::device::mock::MockDevice::SuspendReplyDoneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::mock::MockDevice::SuspendReplyDoneRequest, action_id) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-blobfs/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-blobfs/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..322171dc
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-blobfs/gen/llcpp/fidl.cc
@@ -0,0 +1,503 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/blobfs/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace blobfs {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kCorruptBlobHandler_CorruptBlob_Ordinal = 0x432ee88e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCorruptBlobHandler_CorruptBlob_GenOrdinal = 0x264e37ffa416cdf1lu;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_CorruptBlobHandlerCorruptBlobRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_CorruptBlobHandlerCorruptBlobResponseTable;
+
+} // namespace
+template <>
+CorruptBlobHandler::ResultOf::CorruptBlob_Impl<CorruptBlobHandler::CorruptBlobResponse>::CorruptBlob_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> merkleroot) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CorruptBlobRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ CorruptBlobRequest _request = {};
+ _request.merkleroot = std::move(merkleroot);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CorruptBlobRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ CorruptBlobHandler::InPlace::CorruptBlob(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+CorruptBlobHandler::ResultOf::CorruptBlob CorruptBlobHandler::SyncClient::CorruptBlob(::fidl::VectorView<uint8_t> merkleroot) {
+ return ResultOf::CorruptBlob(::zx::unowned_channel(this->channel_), std::move(merkleroot));
+}
+
+CorruptBlobHandler::ResultOf::CorruptBlob CorruptBlobHandler::Call::CorruptBlob(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> merkleroot) {
+ return ResultOf::CorruptBlob(std::move(_client_end), std::move(merkleroot));
+}
+
+template <>
+CorruptBlobHandler::UnownedResultOf::CorruptBlob_Impl<CorruptBlobHandler::CorruptBlobResponse>::CorruptBlob_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> merkleroot, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CorruptBlobRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CorruptBlobResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ CorruptBlobRequest _request = {};
+ _request.merkleroot = std::move(merkleroot);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CorruptBlobRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ CorruptBlobHandler::InPlace::CorruptBlob(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+CorruptBlobHandler::UnownedResultOf::CorruptBlob CorruptBlobHandler::SyncClient::CorruptBlob(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> merkleroot, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CorruptBlob(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(merkleroot), std::move(_response_buffer));
+}
+
+CorruptBlobHandler::UnownedResultOf::CorruptBlob CorruptBlobHandler::Call::CorruptBlob(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> merkleroot, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CorruptBlob(std::move(_client_end), std::move(_request_buffer), std::move(merkleroot), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<CorruptBlobHandler::CorruptBlobResponse> CorruptBlobHandler::InPlace::CorruptBlob(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CorruptBlobRequest> params, ::fidl::BytePart response_buffer) {
+ CorruptBlobHandler::SetTransactionHeaderFor::CorruptBlobRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<CorruptBlobHandler::CorruptBlobResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CorruptBlobRequest, CorruptBlobResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<CorruptBlobHandler::CorruptBlobResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool CorruptBlobHandler::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kCorruptBlobHandler_CorruptBlob_Ordinal:
+ case kCorruptBlobHandler_CorruptBlob_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CorruptBlobRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CorruptBlob(std::move(message->merkleroot),
+ Interface::CorruptBlobCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool CorruptBlobHandler::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void CorruptBlobHandler::Interface::CorruptBlobCompleterBase::Reply(::llcpp::fuchsia::blobfs::TakeAction action) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CorruptBlobResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CorruptBlobResponse*>(_write_bytes);
+ CorruptBlobHandler::SetTransactionHeaderFor::CorruptBlobResponse(
+ ::fidl::DecodedMessage<CorruptBlobResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CorruptBlobResponse::PrimarySize,
+ CorruptBlobResponse::PrimarySize)));
+ _response.action = std::move(action);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CorruptBlobResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CorruptBlobResponse>(std::move(_response_bytes)));
+}
+
+void CorruptBlobHandler::Interface::CorruptBlobCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::blobfs::TakeAction action) {
+ if (_buffer.capacity() < CorruptBlobResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CorruptBlobResponse*>(_buffer.data());
+ CorruptBlobHandler::SetTransactionHeaderFor::CorruptBlobResponse(
+ ::fidl::DecodedMessage<CorruptBlobResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CorruptBlobResponse::PrimarySize,
+ CorruptBlobResponse::PrimarySize)));
+ _response.action = std::move(action);
+ _buffer.set_actual(sizeof(CorruptBlobResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CorruptBlobResponse>(std::move(_buffer)));
+}
+
+void CorruptBlobHandler::Interface::CorruptBlobCompleterBase::Reply(::fidl::DecodedMessage<CorruptBlobResponse> params) {
+ CorruptBlobHandler::SetTransactionHeaderFor::CorruptBlobResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void CorruptBlobHandler::SetTransactionHeaderFor::CorruptBlobRequest(const ::fidl::DecodedMessage<CorruptBlobHandler::CorruptBlobRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCorruptBlobHandler_CorruptBlob_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void CorruptBlobHandler::SetTransactionHeaderFor::CorruptBlobResponse(const ::fidl::DecodedMessage<CorruptBlobHandler::CorruptBlobResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCorruptBlobHandler_CorruptBlob_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBlobfsAdmin_HandleCorruptBlobs_Ordinal = 0x22c0c04c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBlobfsAdmin_HandleCorruptBlobs_GenOrdinal = 0x5f405690ad00f87elu;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlobfsAdminHandleCorruptBlobsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlobfsAdminHandleCorruptBlobsResponseTable;
+
+} // namespace
+template <>
+BlobfsAdmin::ResultOf::HandleCorruptBlobs_Impl<BlobfsAdmin::HandleCorruptBlobsResponse>::HandleCorruptBlobs_Impl(::zx::unowned_channel _client_end, ::zx::channel handler) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<HandleCorruptBlobsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, HandleCorruptBlobsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<HandleCorruptBlobsRequest*>(_write_bytes);
+ _request.handler = std::move(handler);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(HandleCorruptBlobsRequest));
+ ::fidl::DecodedMessage<HandleCorruptBlobsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BlobfsAdmin::InPlace::HandleCorruptBlobs(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BlobfsAdmin::ResultOf::HandleCorruptBlobs BlobfsAdmin::SyncClient::HandleCorruptBlobs(::zx::channel handler) {
+ return ResultOf::HandleCorruptBlobs(::zx::unowned_channel(this->channel_), std::move(handler));
+}
+
+BlobfsAdmin::ResultOf::HandleCorruptBlobs BlobfsAdmin::Call::HandleCorruptBlobs(::zx::unowned_channel _client_end, ::zx::channel handler) {
+ return ResultOf::HandleCorruptBlobs(std::move(_client_end), std::move(handler));
+}
+
+template <>
+BlobfsAdmin::UnownedResultOf::HandleCorruptBlobs_Impl<BlobfsAdmin::HandleCorruptBlobsResponse>::HandleCorruptBlobs_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel handler, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < HandleCorruptBlobsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<HandleCorruptBlobsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, HandleCorruptBlobsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<HandleCorruptBlobsRequest*>(_request_buffer.data());
+ _request.handler = std::move(handler);
+ _request_buffer.set_actual(sizeof(HandleCorruptBlobsRequest));
+ ::fidl::DecodedMessage<HandleCorruptBlobsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BlobfsAdmin::InPlace::HandleCorruptBlobs(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BlobfsAdmin::UnownedResultOf::HandleCorruptBlobs BlobfsAdmin::SyncClient::HandleCorruptBlobs(::fidl::BytePart _request_buffer, ::zx::channel handler, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::HandleCorruptBlobs(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(handler), std::move(_response_buffer));
+}
+
+BlobfsAdmin::UnownedResultOf::HandleCorruptBlobs BlobfsAdmin::Call::HandleCorruptBlobs(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel handler, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::HandleCorruptBlobs(std::move(_client_end), std::move(_request_buffer), std::move(handler), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BlobfsAdmin::HandleCorruptBlobsResponse> BlobfsAdmin::InPlace::HandleCorruptBlobs(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<HandleCorruptBlobsRequest> params, ::fidl::BytePart response_buffer) {
+ BlobfsAdmin::SetTransactionHeaderFor::HandleCorruptBlobsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BlobfsAdmin::HandleCorruptBlobsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<HandleCorruptBlobsRequest, HandleCorruptBlobsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BlobfsAdmin::HandleCorruptBlobsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool BlobfsAdmin::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBlobfsAdmin_HandleCorruptBlobs_Ordinal:
+ case kBlobfsAdmin_HandleCorruptBlobs_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<HandleCorruptBlobsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->HandleCorruptBlobs(std::move(message->handler),
+ Interface::HandleCorruptBlobsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool BlobfsAdmin::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void BlobfsAdmin::Interface::HandleCorruptBlobsCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<HandleCorruptBlobsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<HandleCorruptBlobsResponse*>(_write_bytes);
+ BlobfsAdmin::SetTransactionHeaderFor::HandleCorruptBlobsResponse(
+ ::fidl::DecodedMessage<HandleCorruptBlobsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ HandleCorruptBlobsResponse::PrimarySize,
+ HandleCorruptBlobsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(HandleCorruptBlobsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<HandleCorruptBlobsResponse>(std::move(_response_bytes)));
+}
+
+void BlobfsAdmin::Interface::HandleCorruptBlobsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < HandleCorruptBlobsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<HandleCorruptBlobsResponse*>(_buffer.data());
+ BlobfsAdmin::SetTransactionHeaderFor::HandleCorruptBlobsResponse(
+ ::fidl::DecodedMessage<HandleCorruptBlobsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ HandleCorruptBlobsResponse::PrimarySize,
+ HandleCorruptBlobsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(HandleCorruptBlobsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<HandleCorruptBlobsResponse>(std::move(_buffer)));
+}
+
+void BlobfsAdmin::Interface::HandleCorruptBlobsCompleterBase::Reply(::fidl::DecodedMessage<HandleCorruptBlobsResponse> params) {
+ BlobfsAdmin::SetTransactionHeaderFor::HandleCorruptBlobsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void BlobfsAdmin::SetTransactionHeaderFor::HandleCorruptBlobsRequest(const ::fidl::DecodedMessage<BlobfsAdmin::HandleCorruptBlobsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlobfsAdmin_HandleCorruptBlobs_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BlobfsAdmin::SetTransactionHeaderFor::HandleCorruptBlobsResponse(const ::fidl::DecodedMessage<BlobfsAdmin::HandleCorruptBlobsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlobfsAdmin_HandleCorruptBlobs_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBlobfs_GetAllocatedRegions_Ordinal = 0xf6a24a800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBlobfs_GetAllocatedRegions_GenOrdinal = 0x3e4b9606dbb8073dlu;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlobfsGetAllocatedRegionsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlobfsGetAllocatedRegionsResponseTable;
+
+} // namespace
+template <>
+Blobfs::ResultOf::GetAllocatedRegions_Impl<Blobfs::GetAllocatedRegionsResponse>::GetAllocatedRegions_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAllocatedRegionsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAllocatedRegionsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAllocatedRegionsRequest));
+ ::fidl::DecodedMessage<GetAllocatedRegionsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Blobfs::InPlace::GetAllocatedRegions(std::move(_client_end), Super::response_buffer()));
+}
+
+Blobfs::ResultOf::GetAllocatedRegions Blobfs::SyncClient::GetAllocatedRegions() {
+ return ResultOf::GetAllocatedRegions(::zx::unowned_channel(this->channel_));
+}
+
+Blobfs::ResultOf::GetAllocatedRegions Blobfs::Call::GetAllocatedRegions(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAllocatedRegions(std::move(_client_end));
+}
+
+template <>
+Blobfs::UnownedResultOf::GetAllocatedRegions_Impl<Blobfs::GetAllocatedRegionsResponse>::GetAllocatedRegions_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAllocatedRegionsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAllocatedRegionsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAllocatedRegionsRequest));
+ ::fidl::DecodedMessage<GetAllocatedRegionsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Blobfs::InPlace::GetAllocatedRegions(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Blobfs::UnownedResultOf::GetAllocatedRegions Blobfs::SyncClient::GetAllocatedRegions(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAllocatedRegions(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Blobfs::UnownedResultOf::GetAllocatedRegions Blobfs::Call::GetAllocatedRegions(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAllocatedRegions(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Blobfs::GetAllocatedRegionsResponse> Blobfs::InPlace::GetAllocatedRegions(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAllocatedRegionsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAllocatedRegionsRequest> params(std::move(_request_buffer));
+ Blobfs::SetTransactionHeaderFor::GetAllocatedRegionsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Blobfs::GetAllocatedRegionsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAllocatedRegionsRequest, GetAllocatedRegionsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Blobfs::GetAllocatedRegionsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Blobfs::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBlobfs_GetAllocatedRegions_Ordinal:
+ case kBlobfs_GetAllocatedRegions_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAllocatedRegionsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAllocatedRegions(
+ Interface::GetAllocatedRegionsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Blobfs::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Blobfs::Interface::GetAllocatedRegionsCompleterBase::Reply(int32_t status, ::zx::vmo regions, uint64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAllocatedRegionsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAllocatedRegionsResponse*>(_write_bytes);
+ Blobfs::SetTransactionHeaderFor::GetAllocatedRegionsResponse(
+ ::fidl::DecodedMessage<GetAllocatedRegionsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAllocatedRegionsResponse::PrimarySize,
+ GetAllocatedRegionsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.regions = std::move(regions);
+ _response.count = std::move(count);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAllocatedRegionsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAllocatedRegionsResponse>(std::move(_response_bytes)));
+}
+
+void Blobfs::Interface::GetAllocatedRegionsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::vmo regions, uint64_t count) {
+ if (_buffer.capacity() < GetAllocatedRegionsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAllocatedRegionsResponse*>(_buffer.data());
+ Blobfs::SetTransactionHeaderFor::GetAllocatedRegionsResponse(
+ ::fidl::DecodedMessage<GetAllocatedRegionsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAllocatedRegionsResponse::PrimarySize,
+ GetAllocatedRegionsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.regions = std::move(regions);
+ _response.count = std::move(count);
+ _buffer.set_actual(sizeof(GetAllocatedRegionsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAllocatedRegionsResponse>(std::move(_buffer)));
+}
+
+void Blobfs::Interface::GetAllocatedRegionsCompleterBase::Reply(::fidl::DecodedMessage<GetAllocatedRegionsResponse> params) {
+ Blobfs::SetTransactionHeaderFor::GetAllocatedRegionsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Blobfs::SetTransactionHeaderFor::GetAllocatedRegionsRequest(const ::fidl::DecodedMessage<Blobfs::GetAllocatedRegionsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlobfs_GetAllocatedRegions_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Blobfs::SetTransactionHeaderFor::GetAllocatedRegionsResponse(const ::fidl::DecodedMessage<Blobfs::GetAllocatedRegionsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlobfs_GetAllocatedRegions_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace blobfs
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-blobfs/gen/llcpp/include/fuchsia/blobfs/llcpp/fidl.h b/zircon/system/fidl/fuchsia-blobfs/gen/llcpp/include/fuchsia/blobfs/llcpp/fidl.h
new file mode 100644
index 0000000..ab03d04
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-blobfs/gen/llcpp/include/fuchsia/blobfs/llcpp/fidl.h
@@ -0,0 +1,660 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace blobfs {
+
+enum class TakeAction : uint8_t {
+ RETURN_ERROR = 0u,
+ DELETE_AND_HANG = 1u,
+ DELETE_AND_RETURN_ERROR = 2u,
+};
+
+
+class CorruptBlobHandler;
+class BlobfsAdmin;
+class Blobfs;
+struct BlockRegion;
+
+extern "C" const fidl_type_t v1_fuchsia_blobfs_CorruptBlobHandlerCorruptBlobRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_CorruptBlobHandlerCorruptBlobResponseTable;
+
+class CorruptBlobHandler final {
+ CorruptBlobHandler() = delete;
+ public:
+
+ struct CorruptBlobResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::blobfs::TakeAction action;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_blobfs_CorruptBlobHandlerCorruptBlobResponseTable;
+ 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 CorruptBlobRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> merkleroot;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_blobfs_CorruptBlobHandlerCorruptBlobRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = CorruptBlobResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class CorruptBlob_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CorruptBlob_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> merkleroot);
+ ~CorruptBlob_Impl() = default;
+ CorruptBlob_Impl(CorruptBlob_Impl&& other) = default;
+ CorruptBlob_Impl& operator=(CorruptBlob_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 CorruptBlob = CorruptBlob_Impl<CorruptBlobResponse>;
+ };
+
+ // 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 CorruptBlob_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CorruptBlob_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> merkleroot, ::fidl::BytePart _response_buffer);
+ ~CorruptBlob_Impl() = default;
+ CorruptBlob_Impl(CorruptBlob_Impl&& other) = default;
+ CorruptBlob_Impl& operator=(CorruptBlob_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 CorruptBlob = CorruptBlob_Impl<CorruptBlobResponse>;
+ };
+
+ 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 120 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CorruptBlob CorruptBlob(::fidl::VectorView<uint8_t> merkleroot);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CorruptBlob CorruptBlob(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> merkleroot, ::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 120 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CorruptBlob CorruptBlob(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> merkleroot);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CorruptBlob CorruptBlob(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> merkleroot, ::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<CorruptBlobResponse> CorruptBlob(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CorruptBlobRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = CorruptBlobHandler;
+ using _Base = ::fidl::CompleterBase;
+
+ class CorruptBlobCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::blobfs::TakeAction action);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::blobfs::TakeAction action);
+ void Reply(::fidl::DecodedMessage<CorruptBlobResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CorruptBlobCompleter = ::fidl::Completer<CorruptBlobCompleterBase>;
+
+ virtual void CorruptBlob(::fidl::VectorView<uint8_t> merkleroot, CorruptBlobCompleter::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 CorruptBlobRequest(const ::fidl::DecodedMessage<CorruptBlobHandler::CorruptBlobRequest>& _msg);
+ static void CorruptBlobResponse(const ::fidl::DecodedMessage<CorruptBlobHandler::CorruptBlobResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlobfsAdminHandleCorruptBlobsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlobfsAdminHandleCorruptBlobsResponseTable;
+
+class BlobfsAdmin final {
+ BlobfsAdmin() = delete;
+ public:
+
+ struct HandleCorruptBlobsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_blobfs_BlobfsAdminHandleCorruptBlobsResponseTable;
+ 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 HandleCorruptBlobsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel handler;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_blobfs_BlobfsAdminHandleCorruptBlobsRequestTable;
+ 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 = HandleCorruptBlobsResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class HandleCorruptBlobs_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ HandleCorruptBlobs_Impl(::zx::unowned_channel _client_end, ::zx::channel handler);
+ ~HandleCorruptBlobs_Impl() = default;
+ HandleCorruptBlobs_Impl(HandleCorruptBlobs_Impl&& other) = default;
+ HandleCorruptBlobs_Impl& operator=(HandleCorruptBlobs_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 HandleCorruptBlobs = HandleCorruptBlobs_Impl<HandleCorruptBlobsResponse>;
+ };
+
+ // 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 HandleCorruptBlobs_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ HandleCorruptBlobs_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel handler, ::fidl::BytePart _response_buffer);
+ ~HandleCorruptBlobs_Impl() = default;
+ HandleCorruptBlobs_Impl(HandleCorruptBlobs_Impl&& other) = default;
+ HandleCorruptBlobs_Impl& operator=(HandleCorruptBlobs_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 HandleCorruptBlobs = HandleCorruptBlobs_Impl<HandleCorruptBlobsResponse>;
+ };
+
+ 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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::HandleCorruptBlobs HandleCorruptBlobs(::zx::channel handler);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::HandleCorruptBlobs HandleCorruptBlobs(::fidl::BytePart _request_buffer, ::zx::channel handler, ::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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::HandleCorruptBlobs HandleCorruptBlobs(::zx::unowned_channel _client_end, ::zx::channel handler);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::HandleCorruptBlobs HandleCorruptBlobs(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel handler, ::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<HandleCorruptBlobsResponse> HandleCorruptBlobs(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<HandleCorruptBlobsRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = BlobfsAdmin;
+ using _Base = ::fidl::CompleterBase;
+
+ class HandleCorruptBlobsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<HandleCorruptBlobsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using HandleCorruptBlobsCompleter = ::fidl::Completer<HandleCorruptBlobsCompleterBase>;
+
+ virtual void HandleCorruptBlobs(::zx::channel handler, HandleCorruptBlobsCompleter::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 HandleCorruptBlobsRequest(const ::fidl::DecodedMessage<BlobfsAdmin::HandleCorruptBlobsRequest>& _msg);
+ static void HandleCorruptBlobsResponse(const ::fidl::DecodedMessage<BlobfsAdmin::HandleCorruptBlobsResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlobfsGetAllocatedRegionsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlobfsGetAllocatedRegionsResponseTable;
+
+class Blobfs final {
+ Blobfs() = delete;
+ public:
+
+ struct GetAllocatedRegionsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::vmo regions;
+ uint64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_blobfs_BlobfsGetAllocatedRegionsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 GetAllocatedRegionsRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetAllocatedRegions_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAllocatedRegions_Impl(::zx::unowned_channel _client_end);
+ ~GetAllocatedRegions_Impl() = default;
+ GetAllocatedRegions_Impl(GetAllocatedRegions_Impl&& other) = default;
+ GetAllocatedRegions_Impl& operator=(GetAllocatedRegions_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 GetAllocatedRegions = GetAllocatedRegions_Impl<GetAllocatedRegionsResponse>;
+ };
+
+ // 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 GetAllocatedRegions_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAllocatedRegions_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAllocatedRegions_Impl() = default;
+ GetAllocatedRegions_Impl(GetAllocatedRegions_Impl&& other) = default;
+ GetAllocatedRegions_Impl& operator=(GetAllocatedRegions_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 GetAllocatedRegions = GetAllocatedRegions_Impl<GetAllocatedRegionsResponse>;
+ };
+
+ 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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAllocatedRegions GetAllocatedRegions();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAllocatedRegions GetAllocatedRegions(::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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAllocatedRegions GetAllocatedRegions(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAllocatedRegions GetAllocatedRegions(::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<GetAllocatedRegionsResponse> GetAllocatedRegions(::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 = Blobfs;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetAllocatedRegionsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::vmo regions, uint64_t count);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::vmo regions, uint64_t count);
+ void Reply(::fidl::DecodedMessage<GetAllocatedRegionsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAllocatedRegionsCompleter = ::fidl::Completer<GetAllocatedRegionsCompleterBase>;
+
+ virtual void GetAllocatedRegions(GetAllocatedRegionsCompleter::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 GetAllocatedRegionsRequest(const ::fidl::DecodedMessage<Blobfs::GetAllocatedRegionsRequest>& _msg);
+ static void GetAllocatedRegionsResponse(const ::fidl::DecodedMessage<Blobfs::GetAllocatedRegionsResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_blobfs_BlockRegionTable;
+
+struct BlockRegion {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_blobfs_BlockRegionTable;
+ 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;
+
+ uint64_t offset = {};
+
+ uint64_t length = {};
+};
+
+} // namespace blobfs
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobRequest)
+ == ::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobRequest, merkleroot) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobResponse)
+ == ::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::CorruptBlobHandler::CorruptBlobResponse, action) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsRequest)
+ == ::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsRequest, handler) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsResponse)
+ == ::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::BlobfsAdmin::HandleCorruptBlobsResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::blobfs::Blobfs::GetAllocatedRegionsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::blobfs::Blobfs::GetAllocatedRegionsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::blobfs::Blobfs::GetAllocatedRegionsResponse)
+ == ::llcpp::fuchsia::blobfs::Blobfs::GetAllocatedRegionsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::Blobfs::GetAllocatedRegionsResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::Blobfs::GetAllocatedRegionsResponse, regions) == 20);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::Blobfs::GetAllocatedRegionsResponse, count) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::blobfs::BlockRegion> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::blobfs::BlockRegion>);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::BlockRegion, offset) == 0);
+static_assert(offsetof(::llcpp::fuchsia::blobfs::BlockRegion, length) == 8);
+static_assert(sizeof(::llcpp::fuchsia::blobfs::BlockRegion) == ::llcpp::fuchsia::blobfs::BlockRegion::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-boot/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-boot/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..e1e6809
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-boot/gen/llcpp/fidl.cc
@@ -0,0 +1,1297 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/boot/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace boot {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kWriteOnlyLog_Get_Ordinal = 0x6bf285c200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kWriteOnlyLog_Get_GenOrdinal = 0x4579dac289d3007lu;
+extern "C" const fidl_type_t v1_fuchsia_boot_WriteOnlyLogGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_WriteOnlyLogGetResponseTable;
+
+} // namespace
+template <>
+WriteOnlyLog::ResultOf::Get_Impl<WriteOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ WriteOnlyLog::InPlace::Get(std::move(_client_end), Super::response_buffer()));
+}
+
+WriteOnlyLog::ResultOf::Get WriteOnlyLog::SyncClient::Get() {
+ return ResultOf::Get(::zx::unowned_channel(this->channel_));
+}
+
+WriteOnlyLog::ResultOf::Get WriteOnlyLog::Call::Get(::zx::unowned_channel _client_end) {
+ return ResultOf::Get(std::move(_client_end));
+}
+
+template <>
+WriteOnlyLog::UnownedResultOf::Get_Impl<WriteOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ WriteOnlyLog::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
+}
+
+WriteOnlyLog::UnownedResultOf::Get WriteOnlyLog::SyncClient::Get(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+WriteOnlyLog::UnownedResultOf::Get WriteOnlyLog::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<WriteOnlyLog::GetResponse> WriteOnlyLog::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer));
+ WriteOnlyLog::SetTransactionHeaderFor::GetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<WriteOnlyLog::GetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRequest, GetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<WriteOnlyLog::GetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool WriteOnlyLog::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kWriteOnlyLog_Get_Ordinal:
+ case kWriteOnlyLog_Get_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Get(
+ Interface::GetCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool WriteOnlyLog::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void WriteOnlyLog::Interface::GetCompleterBase::Reply(::zx::debuglog log) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes);
+ WriteOnlyLog::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.log = std::move(log);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes)));
+}
+
+void WriteOnlyLog::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::debuglog log) {
+ if (_buffer.capacity() < GetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
+ WriteOnlyLog::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.log = std::move(log);
+ _buffer.set_actual(sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
+}
+
+void WriteOnlyLog::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
+ WriteOnlyLog::SetTransactionHeaderFor::GetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void WriteOnlyLog::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<WriteOnlyLog::GetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kWriteOnlyLog_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void WriteOnlyLog::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<WriteOnlyLog::GetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kWriteOnlyLog_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kReadOnlyLog_Get_Ordinal = 0x6ef326c600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kReadOnlyLog_Get_GenOrdinal = 0x6f3ceba5eca871fflu;
+extern "C" const fidl_type_t v1_fuchsia_boot_ReadOnlyLogGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_ReadOnlyLogGetResponseTable;
+
+} // namespace
+template <>
+ReadOnlyLog::ResultOf::Get_Impl<ReadOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ ReadOnlyLog::InPlace::Get(std::move(_client_end), Super::response_buffer()));
+}
+
+ReadOnlyLog::ResultOf::Get ReadOnlyLog::SyncClient::Get() {
+ return ResultOf::Get(::zx::unowned_channel(this->channel_));
+}
+
+ReadOnlyLog::ResultOf::Get ReadOnlyLog::Call::Get(::zx::unowned_channel _client_end) {
+ return ResultOf::Get(std::move(_client_end));
+}
+
+template <>
+ReadOnlyLog::UnownedResultOf::Get_Impl<ReadOnlyLog::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ ReadOnlyLog::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
+}
+
+ReadOnlyLog::UnownedResultOf::Get ReadOnlyLog::SyncClient::Get(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+ReadOnlyLog::UnownedResultOf::Get ReadOnlyLog::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ReadOnlyLog::GetResponse> ReadOnlyLog::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer));
+ ReadOnlyLog::SetTransactionHeaderFor::GetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ReadOnlyLog::GetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRequest, GetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ReadOnlyLog::GetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool ReadOnlyLog::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kReadOnlyLog_Get_Ordinal:
+ case kReadOnlyLog_Get_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Get(
+ Interface::GetCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool ReadOnlyLog::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void ReadOnlyLog::Interface::GetCompleterBase::Reply(::zx::debuglog log) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes);
+ ReadOnlyLog::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.log = std::move(log);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes)));
+}
+
+void ReadOnlyLog::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::debuglog log) {
+ if (_buffer.capacity() < GetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
+ ReadOnlyLog::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.log = std::move(log);
+ _buffer.set_actual(sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
+}
+
+void ReadOnlyLog::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
+ ReadOnlyLog::SetTransactionHeaderFor::GetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void ReadOnlyLog::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<ReadOnlyLog::GetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kReadOnlyLog_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ReadOnlyLog::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<ReadOnlyLog::GetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kReadOnlyLog_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kItems_Get_Ordinal = 0x6462c85400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kItems_Get_GenOrdinal = 0x542db3f176641edclu;
+extern "C" const fidl_type_t v1_fuchsia_boot_ItemsGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_ItemsGetResponseTable;
+
+} // namespace
+template <>
+Items::ResultOf::Get_Impl<Items::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, uint32_t type, uint32_t extra) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetRequest*>(_write_bytes);
+ _request.type = std::move(type);
+ _request.extra = std::move(extra);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Items::InPlace::Get(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Items::ResultOf::Get Items::SyncClient::Get(uint32_t type, uint32_t extra) {
+ return ResultOf::Get(::zx::unowned_channel(this->channel_), std::move(type), std::move(extra));
+}
+
+Items::ResultOf::Get Items::Call::Get(::zx::unowned_channel _client_end, uint32_t type, uint32_t extra) {
+ return ResultOf::Get(std::move(_client_end), std::move(type), std::move(extra));
+}
+
+template <>
+Items::UnownedResultOf::Get_Impl<Items::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetRequest*>(_request_buffer.data());
+ _request.type = std::move(type);
+ _request.extra = std::move(extra);
+ _request_buffer.set_actual(sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Items::InPlace::Get(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Items::UnownedResultOf::Get Items::SyncClient::Get(::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(extra), std::move(_response_buffer));
+}
+
+Items::UnownedResultOf::Get Items::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(extra), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Items::GetResponse> Items::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetRequest> params, ::fidl::BytePart response_buffer) {
+ Items::SetTransactionHeaderFor::GetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Items::GetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRequest, GetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Items::GetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Items::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kItems_Get_Ordinal:
+ case kItems_Get_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Get(std::move(message->type), std::move(message->extra),
+ Interface::GetCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Items::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Items::Interface::GetCompleterBase::Reply(::zx::vmo payload, uint32_t length) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes);
+ Items::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.payload = std::move(payload);
+ _response.length = std::move(length);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes)));
+}
+
+void Items::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo payload, uint32_t length) {
+ if (_buffer.capacity() < GetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
+ Items::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.payload = std::move(payload);
+ _response.length = std::move(length);
+ _buffer.set_actual(sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
+}
+
+void Items::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
+ Items::SetTransactionHeaderFor::GetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Items::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<Items::GetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kItems_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Items::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<Items::GetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kItems_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kFactoryItems_Get_Ordinal = 0x18be2c3500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFactoryItems_Get_GenOrdinal = 0x2f0dcb1aba41b6d9lu;
+extern "C" const fidl_type_t v1_fuchsia_boot_FactoryItemsGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_FactoryItemsGetResponseTable;
+
+} // namespace
+template <>
+FactoryItems::ResultOf::Get_Impl<FactoryItems::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, uint32_t extra) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetRequest*>(_write_bytes);
+ _request.extra = std::move(extra);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ FactoryItems::InPlace::Get(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+FactoryItems::ResultOf::Get FactoryItems::SyncClient::Get(uint32_t extra) {
+ return ResultOf::Get(::zx::unowned_channel(this->channel_), std::move(extra));
+}
+
+FactoryItems::ResultOf::Get FactoryItems::Call::Get(::zx::unowned_channel _client_end, uint32_t extra) {
+ return ResultOf::Get(std::move(_client_end), std::move(extra));
+}
+
+template <>
+FactoryItems::UnownedResultOf::Get_Impl<FactoryItems::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetRequest*>(_request_buffer.data());
+ _request.extra = std::move(extra);
+ _request_buffer.set_actual(sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ FactoryItems::InPlace::Get(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+FactoryItems::UnownedResultOf::Get FactoryItems::SyncClient::Get(::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(extra), std::move(_response_buffer));
+}
+
+FactoryItems::UnownedResultOf::Get FactoryItems::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(std::move(_client_end), std::move(_request_buffer), std::move(extra), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<FactoryItems::GetResponse> FactoryItems::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetRequest> params, ::fidl::BytePart response_buffer) {
+ FactoryItems::SetTransactionHeaderFor::GetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<FactoryItems::GetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRequest, GetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<FactoryItems::GetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool FactoryItems::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kFactoryItems_Get_Ordinal:
+ case kFactoryItems_Get_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Get(std::move(message->extra),
+ Interface::GetCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool FactoryItems::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void FactoryItems::Interface::GetCompleterBase::Reply(::zx::vmo payload, uint32_t length) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes);
+ FactoryItems::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.payload = std::move(payload);
+ _response.length = std::move(length);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes)));
+}
+
+void FactoryItems::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo payload, uint32_t length) {
+ if (_buffer.capacity() < GetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
+ FactoryItems::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.payload = std::move(payload);
+ _response.length = std::move(length);
+ _buffer.set_actual(sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
+}
+
+void FactoryItems::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
+ FactoryItems::SetTransactionHeaderFor::GetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void FactoryItems::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<FactoryItems::GetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFactoryItems_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void FactoryItems::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<FactoryItems::GetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFactoryItems_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kRootResource_Get_Ordinal = 0x2e9e3a1400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRootResource_Get_GenOrdinal = 0x5a1df646e4df6f78lu;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootResourceGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootResourceGetResponseTable;
+
+} // namespace
+template <>
+RootResource::ResultOf::Get_Impl<RootResource::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ RootResource::InPlace::Get(std::move(_client_end), Super::response_buffer()));
+}
+
+RootResource::ResultOf::Get RootResource::SyncClient::Get() {
+ return ResultOf::Get(::zx::unowned_channel(this->channel_));
+}
+
+RootResource::ResultOf::Get RootResource::Call::Get(::zx::unowned_channel _client_end) {
+ return ResultOf::Get(std::move(_client_end));
+}
+
+template <>
+RootResource::UnownedResultOf::Get_Impl<RootResource::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ RootResource::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
+}
+
+RootResource::UnownedResultOf::Get RootResource::SyncClient::Get(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+RootResource::UnownedResultOf::Get RootResource::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<RootResource::GetResponse> RootResource::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer));
+ RootResource::SetTransactionHeaderFor::GetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RootResource::GetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRequest, GetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RootResource::GetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool RootResource::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kRootResource_Get_Ordinal:
+ case kRootResource_Get_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Get(
+ Interface::GetCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool RootResource::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void RootResource::Interface::GetCompleterBase::Reply(::zx::resource resource) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes);
+ RootResource::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.resource = std::move(resource);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes)));
+}
+
+void RootResource::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::resource resource) {
+ if (_buffer.capacity() < GetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
+ RootResource::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.resource = std::move(resource);
+ _buffer.set_actual(sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
+}
+
+void RootResource::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
+ RootResource::SetTransactionHeaderFor::GetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void RootResource::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootResource::GetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootResource_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void RootResource::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootResource::GetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootResource_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kRootJob_Get_Ordinal = 0x7e473a2400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRootJob_Get_GenOrdinal = 0x70e2566b29e1af06lu;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootJobGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootJobGetResponseTable;
+
+} // namespace
+template <>
+RootJob::ResultOf::Get_Impl<RootJob::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ RootJob::InPlace::Get(std::move(_client_end), Super::response_buffer()));
+}
+
+RootJob::ResultOf::Get RootJob::SyncClient::Get() {
+ return ResultOf::Get(::zx::unowned_channel(this->channel_));
+}
+
+RootJob::ResultOf::Get RootJob::Call::Get(::zx::unowned_channel _client_end) {
+ return ResultOf::Get(std::move(_client_end));
+}
+
+template <>
+RootJob::UnownedResultOf::Get_Impl<RootJob::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ RootJob::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
+}
+
+RootJob::UnownedResultOf::Get RootJob::SyncClient::Get(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+RootJob::UnownedResultOf::Get RootJob::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<RootJob::GetResponse> RootJob::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer));
+ RootJob::SetTransactionHeaderFor::GetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RootJob::GetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRequest, GetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RootJob::GetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool RootJob::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kRootJob_Get_Ordinal:
+ case kRootJob_Get_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Get(
+ Interface::GetCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool RootJob::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void RootJob::Interface::GetCompleterBase::Reply(::zx::job job) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes);
+ RootJob::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.job = std::move(job);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes)));
+}
+
+void RootJob::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::job job) {
+ if (_buffer.capacity() < GetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
+ RootJob::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.job = std::move(job);
+ _buffer.set_actual(sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
+}
+
+void RootJob::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
+ RootJob::SetTransactionHeaderFor::GetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void RootJob::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootJob::GetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJob_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void RootJob::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootJob::GetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJob_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kRootJobForInspect_Get_Ordinal = 0x7e473a2400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRootJobForInspect_Get_GenOrdinal = 0x70e2566b29e1af06lu;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootJobForInspectGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootJobForInspectGetResponseTable;
+
+} // namespace
+template <>
+RootJobForInspect::ResultOf::Get_Impl<RootJobForInspect::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ RootJobForInspect::InPlace::Get(std::move(_client_end), Super::response_buffer()));
+}
+
+RootJobForInspect::ResultOf::Get RootJobForInspect::SyncClient::Get() {
+ return ResultOf::Get(::zx::unowned_channel(this->channel_));
+}
+
+RootJobForInspect::ResultOf::Get RootJobForInspect::Call::Get(::zx::unowned_channel _client_end) {
+ return ResultOf::Get(std::move(_client_end));
+}
+
+template <>
+RootJobForInspect::UnownedResultOf::Get_Impl<RootJobForInspect::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ RootJobForInspect::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
+}
+
+RootJobForInspect::UnownedResultOf::Get RootJobForInspect::SyncClient::Get(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+RootJobForInspect::UnownedResultOf::Get RootJobForInspect::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<RootJobForInspect::GetResponse> RootJobForInspect::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer));
+ RootJobForInspect::SetTransactionHeaderFor::GetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RootJobForInspect::GetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRequest, GetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RootJobForInspect::GetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool RootJobForInspect::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kRootJobForInspect_Get_Ordinal:
+ case kRootJobForInspect_Get_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Get(
+ Interface::GetCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool RootJobForInspect::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void RootJobForInspect::Interface::GetCompleterBase::Reply(::zx::job job) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes);
+ RootJobForInspect::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.job = std::move(job);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes)));
+}
+
+void RootJobForInspect::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::job job) {
+ if (_buffer.capacity() < GetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
+ RootJobForInspect::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.job = std::move(job);
+ _buffer.set_actual(sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
+}
+
+void RootJobForInspect::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
+ RootJobForInspect::SetTransactionHeaderFor::GetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void RootJobForInspect::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<RootJobForInspect::GetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJobForInspect_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void RootJobForInspect::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<RootJobForInspect::GetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRootJobForInspect_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kArguments_Get_Ordinal = 0x6e7258e600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kArguments_Get_GenOrdinal = 0x2e594d9c82b93ee3lu;
+extern "C" const fidl_type_t v1_fuchsia_boot_ArgumentsGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_ArgumentsGetResponseTable;
+
+} // namespace
+template <>
+Arguments::ResultOf::Get_Impl<Arguments::GetResponse>::Get_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Arguments::InPlace::Get(std::move(_client_end), Super::response_buffer()));
+}
+
+Arguments::ResultOf::Get Arguments::SyncClient::Get() {
+ return ResultOf::Get(::zx::unowned_channel(this->channel_));
+}
+
+Arguments::ResultOf::Get Arguments::Call::Get(::zx::unowned_channel _client_end) {
+ return ResultOf::Get(std::move(_client_end));
+}
+
+template <>
+Arguments::UnownedResultOf::Get_Impl<Arguments::GetResponse>::Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetRequest));
+ ::fidl::DecodedMessage<GetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Arguments::InPlace::Get(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Arguments::UnownedResultOf::Get Arguments::SyncClient::Get(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Arguments::UnownedResultOf::Get Arguments::Call::Get(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Get(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Arguments::GetResponse> Arguments::InPlace::Get(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetRequest> params(std::move(_request_buffer));
+ Arguments::SetTransactionHeaderFor::GetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Arguments::GetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRequest, GetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Arguments::GetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Arguments::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kArguments_Get_Ordinal:
+ case kArguments_Get_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Get(
+ Interface::GetCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Arguments::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Arguments::Interface::GetCompleterBase::Reply(::zx::vmo vmo, uint64_t size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetResponse*>(_write_bytes);
+ Arguments::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.vmo = std::move(vmo);
+ _response.size = std::move(size);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_response_bytes)));
+}
+
+void Arguments::Interface::GetCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo vmo, uint64_t size) {
+ if (_buffer.capacity() < GetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetResponse*>(_buffer.data());
+ Arguments::SetTransactionHeaderFor::GetResponse(
+ ::fidl::DecodedMessage<GetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetResponse::PrimarySize,
+ GetResponse::PrimarySize)));
+ _response.vmo = std::move(vmo);
+ _response.size = std::move(size);
+ _buffer.set_actual(sizeof(GetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetResponse>(std::move(_buffer)));
+}
+
+void Arguments::Interface::GetCompleterBase::Reply(::fidl::DecodedMessage<GetResponse> params) {
+ Arguments::SetTransactionHeaderFor::GetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Arguments::SetTransactionHeaderFor::GetRequest(const ::fidl::DecodedMessage<Arguments::GetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kArguments_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Arguments::SetTransactionHeaderFor::GetResponse(const ::fidl::DecodedMessage<Arguments::GetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kArguments_Get_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace boot
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-boot/gen/llcpp/include/fuchsia/boot/llcpp/fidl.h b/zircon/system/fidl/fuchsia-boot/gen/llcpp/include/fuchsia/boot/llcpp/fidl.h
new file mode 100644
index 0000000..972d95c
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-boot/gen/llcpp/include/fuchsia/boot/llcpp/fidl.h
@@ -0,0 +1,1641 @@
+// 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/debuglog.h>
+#include <lib/zx/job.h>
+#include <lib/zx/resource.h>
+#include <lib/zx/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace boot {
+
+class WriteOnlyLog;
+class ReadOnlyLog;
+class Items;
+class FactoryItems;
+class RootResource;
+class RootJob;
+class RootJobForInspect;
+class Arguments;
+
+extern "C" const fidl_type_t v1_fuchsia_boot_WriteOnlyLogGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_WriteOnlyLogGetResponseTable;
+
+// Protocol for providing the kernel log, writable.
+class WriteOnlyLog final {
+ WriteOnlyLog() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.boot.WriteOnlyLog";
+
+ struct GetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::debuglog log;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_WriteOnlyLogGetResponseTable;
+ 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 GetRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Get_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ // 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 Get_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ 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_; }
+
+ // Get write-only handle to the kernel `log`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Get Get();
+
+ // Get write-only handle to the kernel `log`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Get Get(::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:
+
+ // Get write-only handle to the kernel `log`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Get Get(::zx::unowned_channel _client_end);
+
+ // Get write-only handle to the kernel `log`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Get Get(::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:
+
+ // Get write-only handle to the kernel `log`.
+ static ::fidl::DecodeResult<GetResponse> Get(::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 = WriteOnlyLog;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetCompleterBase : public _Base {
+ public:
+ void Reply(::zx::debuglog log);
+ void Reply(::fidl::BytePart _buffer, ::zx::debuglog log);
+ void Reply(::fidl::DecodedMessage<GetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCompleter = ::fidl::Completer<GetCompleterBase>;
+
+ virtual void Get(GetCompleter::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 GetRequest(const ::fidl::DecodedMessage<WriteOnlyLog::GetRequest>& _msg);
+ static void GetResponse(const ::fidl::DecodedMessage<WriteOnlyLog::GetResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_boot_ReadOnlyLogGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_ReadOnlyLogGetResponseTable;
+
+// Protocol for providing the kernel log, readable.
+class ReadOnlyLog final {
+ ReadOnlyLog() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.boot.ReadOnlyLog";
+
+ struct GetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::debuglog log;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_ReadOnlyLogGetResponseTable;
+ 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 GetRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Get_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ // 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 Get_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ 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_; }
+
+ // Get read-only handle to the kernel `log`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Get Get();
+
+ // Get read-only handle to the kernel `log`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Get Get(::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:
+
+ // Get read-only handle to the kernel `log`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Get Get(::zx::unowned_channel _client_end);
+
+ // Get read-only handle to the kernel `log`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Get Get(::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:
+
+ // Get read-only handle to the kernel `log`.
+ static ::fidl::DecodeResult<GetResponse> Get(::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 = ReadOnlyLog;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetCompleterBase : public _Base {
+ public:
+ void Reply(::zx::debuglog log);
+ void Reply(::fidl::BytePart _buffer, ::zx::debuglog log);
+ void Reply(::fidl::DecodedMessage<GetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCompleter = ::fidl::Completer<GetCompleterBase>;
+
+ virtual void Get(GetCompleter::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 GetRequest(const ::fidl::DecodedMessage<ReadOnlyLog::GetRequest>& _msg);
+ static void GetResponse(const ::fidl::DecodedMessage<ReadOnlyLog::GetResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_boot_ItemsGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_ItemsGetResponseTable;
+
+// Protocol for retrieving boot item payloads.
+class Items final {
+ Items() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.boot.Items";
+
+ struct GetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo payload;
+ uint32_t length;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_ItemsGetResponseTable;
+ 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;
+ };
+ struct GetRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t type;
+ uint32_t extra;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_ItemsGetRequestTable;
+ 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 = GetResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Get_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, uint32_t type, uint32_t extra);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ // 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 Get_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::fidl::BytePart _response_buffer);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ 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_; }
+
+ // Get a `payload` for a boot item of `type` and `extra`.
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ //
+ // For a list of `type`s, refer to <zircon/boot/image.h>.
+ // For a list of `extra`s, refer to <zircon/boot/driver-config.h>.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Get Get(uint32_t type, uint32_t extra);
+
+ // Get a `payload` for a boot item of `type` and `extra`.
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ //
+ // For a list of `type`s, refer to <zircon/boot/image.h>.
+ // For a list of `extra`s, refer to <zircon/boot/driver-config.h>.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Get Get(::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::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:
+
+ // Get a `payload` for a boot item of `type` and `extra`.
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ //
+ // For a list of `type`s, refer to <zircon/boot/image.h>.
+ // For a list of `extra`s, refer to <zircon/boot/driver-config.h>.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Get Get(::zx::unowned_channel _client_end, uint32_t type, uint32_t extra);
+
+ // Get a `payload` for a boot item of `type` and `extra`.
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ //
+ // For a list of `type`s, refer to <zircon/boot/image.h>.
+ // For a list of `extra`s, refer to <zircon/boot/driver-config.h>.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Get Get(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t type, uint32_t extra, ::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:
+
+ // Get a `payload` for a boot item of `type` and `extra`.
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ //
+ // For a list of `type`s, refer to <zircon/boot/image.h>.
+ // For a list of `extra`s, refer to <zircon/boot/driver-config.h>.
+ static ::fidl::DecodeResult<GetResponse> Get(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Items;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetCompleterBase : public _Base {
+ public:
+ void Reply(::zx::vmo payload, uint32_t length);
+ void Reply(::fidl::BytePart _buffer, ::zx::vmo payload, uint32_t length);
+ void Reply(::fidl::DecodedMessage<GetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCompleter = ::fidl::Completer<GetCompleterBase>;
+
+ virtual void Get(uint32_t type, uint32_t extra, GetCompleter::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 GetRequest(const ::fidl::DecodedMessage<Items::GetRequest>& _msg);
+ static void GetResponse(const ::fidl::DecodedMessage<Items::GetResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_boot_FactoryItemsGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_FactoryItemsGetResponseTable;
+
+// Protocol for retrieving factory boot item payloads.
+class FactoryItems final {
+ FactoryItems() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.boot.FactoryItems";
+
+ struct GetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo payload;
+ uint32_t length;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_FactoryItemsGetResponseTable;
+ 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;
+ };
+ struct GetRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t extra;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_FactoryItemsGetRequestTable;
+ 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 = GetResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Get_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, uint32_t extra);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ // 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 Get_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t extra, ::fidl::BytePart _response_buffer);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ 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_; }
+
+ // Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with
+ // extra field set to `extra`.
+ //
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Get Get(uint32_t extra);
+
+ // Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with
+ // extra field set to `extra`.
+ //
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Get Get(::fidl::BytePart _request_buffer, uint32_t extra, ::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:
+
+ // Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with
+ // extra field set to `extra`.
+ //
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Get Get(::zx::unowned_channel _client_end, uint32_t extra);
+
+ // Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with
+ // extra field set to `extra`.
+ //
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Get Get(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t extra, ::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:
+
+ // Gets a `payload` for a `ZBI_TYPE_STORAGE_BOOTFS_FACTORY` boot item with
+ // extra field set to `extra`.
+ //
+ // NOTE: We return the `length` of the item, as VMOs must be page-aligned.
+ static ::fidl::DecodeResult<GetResponse> Get(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = FactoryItems;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetCompleterBase : public _Base {
+ public:
+ void Reply(::zx::vmo payload, uint32_t length);
+ void Reply(::fidl::BytePart _buffer, ::zx::vmo payload, uint32_t length);
+ void Reply(::fidl::DecodedMessage<GetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCompleter = ::fidl::Completer<GetCompleterBase>;
+
+ virtual void Get(uint32_t extra, GetCompleter::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 GetRequest(const ::fidl::DecodedMessage<FactoryItems::GetRequest>& _msg);
+ static void GetResponse(const ::fidl::DecodedMessage<FactoryItems::GetResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_boot_RootResourceGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootResourceGetResponseTable;
+
+// Protocol for providing the root resource.
+class RootResource final {
+ RootResource() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.boot.RootResource";
+
+ struct GetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::resource resource;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_RootResourceGetResponseTable;
+ 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 GetRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Get_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ // 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 Get_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ 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_; }
+
+ // Get the root |resource|.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Get Get();
+
+ // Get the root |resource|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Get Get(::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:
+
+ // Get the root |resource|.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Get Get(::zx::unowned_channel _client_end);
+
+ // Get the root |resource|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Get Get(::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:
+
+ // Get the root |resource|.
+ static ::fidl::DecodeResult<GetResponse> Get(::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 = RootResource;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetCompleterBase : public _Base {
+ public:
+ void Reply(::zx::resource resource);
+ void Reply(::fidl::BytePart _buffer, ::zx::resource resource);
+ void Reply(::fidl::DecodedMessage<GetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCompleter = ::fidl::Completer<GetCompleterBase>;
+
+ virtual void Get(GetCompleter::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 GetRequest(const ::fidl::DecodedMessage<RootResource::GetRequest>& _msg);
+ static void GetResponse(const ::fidl::DecodedMessage<RootResource::GetResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_boot_RootJobGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootJobGetResponseTable;
+
+// Protocol for providing the root job.
+//
+// TODO(ZX-4072): Do not use this without first consulting the Zircon team.
+class RootJob final {
+ RootJob() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.boot.RootJob";
+
+ struct GetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::job job;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_RootJobGetResponseTable;
+ 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 GetRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Get_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ // 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 Get_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ 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_; }
+
+ // Get the root `job`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Get Get();
+
+ // Get the root `job`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Get Get(::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:
+
+ // Get the root `job`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Get Get(::zx::unowned_channel _client_end);
+
+ // Get the root `job`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Get Get(::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:
+
+ // Get the root `job`.
+ static ::fidl::DecodeResult<GetResponse> Get(::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 = RootJob;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetCompleterBase : public _Base {
+ public:
+ void Reply(::zx::job job);
+ void Reply(::fidl::BytePart _buffer, ::zx::job job);
+ void Reply(::fidl::DecodedMessage<GetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCompleter = ::fidl::Completer<GetCompleterBase>;
+
+ virtual void Get(GetCompleter::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 GetRequest(const ::fidl::DecodedMessage<RootJob::GetRequest>& _msg);
+ static void GetResponse(const ::fidl::DecodedMessage<RootJob::GetResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_boot_RootJobForInspectGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_RootJobForInspectGetResponseTable;
+
+// Protocol for providing the root job with restricted rights, specifically:
+// INSPECT | ENUMERATE | DUPLICATE | TRANSFER
+class RootJobForInspect final {
+ RootJobForInspect() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.boot.RootJobForInspect";
+
+ struct GetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::job job;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_RootJobForInspectGetResponseTable;
+ 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 GetRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Get_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ // 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 Get_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ 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_; }
+
+ // Get the root `job`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Get Get();
+
+ // Get the root `job`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Get Get(::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:
+
+ // Get the root `job`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Get Get(::zx::unowned_channel _client_end);
+
+ // Get the root `job`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Get Get(::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:
+
+ // Get the root `job`.
+ static ::fidl::DecodeResult<GetResponse> Get(::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 = RootJobForInspect;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetCompleterBase : public _Base {
+ public:
+ void Reply(::zx::job job);
+ void Reply(::fidl::BytePart _buffer, ::zx::job job);
+ void Reply(::fidl::DecodedMessage<GetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCompleter = ::fidl::Completer<GetCompleterBase>;
+
+ virtual void Get(GetCompleter::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 GetRequest(const ::fidl::DecodedMessage<RootJobForInspect::GetRequest>& _msg);
+ static void GetResponse(const ::fidl::DecodedMessage<RootJobForInspect::GetResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_boot_ArgumentsGetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_boot_ArgumentsGetResponseTable;
+
+// Protocol for retrieving boot arguments.
+class Arguments final {
+ Arguments() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.boot.Arguments";
+
+ struct GetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo vmo;
+ uint64_t size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_boot_ArgumentsGetResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 GetRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Get_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ // 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 Get_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Get_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Get_Impl() = default;
+ Get_Impl(Get_Impl&& other) = default;
+ Get_Impl& operator=(Get_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 Get = Get_Impl<GetResponse>;
+ };
+
+ 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_; }
+
+ // Get a `vmo` containing boot arguments, along with the `size` of the boot
+ // arguments contained within.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Get Get();
+
+ // Get a `vmo` containing boot arguments, along with the `size` of the boot
+ // arguments contained within.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Get Get(::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:
+
+ // Get a `vmo` containing boot arguments, along with the `size` of the boot
+ // arguments contained within.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Get Get(::zx::unowned_channel _client_end);
+
+ // Get a `vmo` containing boot arguments, along with the `size` of the boot
+ // arguments contained within.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Get Get(::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:
+
+ // Get a `vmo` containing boot arguments, along with the `size` of the boot
+ // arguments contained within.
+ static ::fidl::DecodeResult<GetResponse> Get(::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 = Arguments;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetCompleterBase : public _Base {
+ public:
+ void Reply(::zx::vmo vmo, uint64_t size);
+ void Reply(::fidl::BytePart _buffer, ::zx::vmo vmo, uint64_t size);
+ void Reply(::fidl::DecodedMessage<GetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCompleter = ::fidl::Completer<GetCompleterBase>;
+
+ virtual void Get(GetCompleter::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 GetRequest(const ::fidl::DecodedMessage<Arguments::GetRequest>& _msg);
+ static void GetResponse(const ::fidl::DecodedMessage<Arguments::GetResponse>& _msg);
+ };
+};
+
+} // namespace boot
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::WriteOnlyLog::GetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::WriteOnlyLog::GetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::WriteOnlyLog::GetResponse)
+ == ::llcpp::fuchsia::boot::WriteOnlyLog::GetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::WriteOnlyLog::GetResponse, log) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::ReadOnlyLog::GetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::ReadOnlyLog::GetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::ReadOnlyLog::GetResponse)
+ == ::llcpp::fuchsia::boot::ReadOnlyLog::GetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::ReadOnlyLog::GetResponse, log) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::Items::GetRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::Items::GetRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::Items::GetRequest)
+ == ::llcpp::fuchsia::boot::Items::GetRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::Items::GetRequest, type) == 16);
+static_assert(offsetof(::llcpp::fuchsia::boot::Items::GetRequest, extra) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::Items::GetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::Items::GetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::Items::GetResponse)
+ == ::llcpp::fuchsia::boot::Items::GetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::Items::GetResponse, payload) == 16);
+static_assert(offsetof(::llcpp::fuchsia::boot::Items::GetResponse, length) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::FactoryItems::GetRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::FactoryItems::GetRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::FactoryItems::GetRequest)
+ == ::llcpp::fuchsia::boot::FactoryItems::GetRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::FactoryItems::GetRequest, extra) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::FactoryItems::GetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::FactoryItems::GetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::FactoryItems::GetResponse)
+ == ::llcpp::fuchsia::boot::FactoryItems::GetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::FactoryItems::GetResponse, payload) == 16);
+static_assert(offsetof(::llcpp::fuchsia::boot::FactoryItems::GetResponse, length) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::RootResource::GetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::RootResource::GetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::RootResource::GetResponse)
+ == ::llcpp::fuchsia::boot::RootResource::GetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::RootResource::GetResponse, resource) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::RootJob::GetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::RootJob::GetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::RootJob::GetResponse)
+ == ::llcpp::fuchsia::boot::RootJob::GetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::RootJob::GetResponse, job) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::RootJobForInspect::GetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::RootJobForInspect::GetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::RootJobForInspect::GetResponse)
+ == ::llcpp::fuchsia::boot::RootJobForInspect::GetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::RootJobForInspect::GetResponse, job) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::boot::Arguments::GetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::boot::Arguments::GetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::boot::Arguments::GetResponse)
+ == ::llcpp::fuchsia::boot::Arguments::GetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::boot::Arguments::GetResponse, vmo) == 16);
+static_assert(offsetof(::llcpp::fuchsia::boot::Arguments::GetResponse, size) == 24);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-buttons/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-buttons/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..c470a64
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-buttons/gen/llcpp/fidl.cc
@@ -0,0 +1,453 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/buttons/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace buttons {
+
+void ::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Buttons_RegisterNotify_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Buttons_RegisterNotify_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Buttons_RegisterNotify_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kButtons_GetState_Ordinal = 0x3f5c2ec300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kButtons_GetState_GenOrdinal = 0x10ee35ec461a178alu;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsGetStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsGetStateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kButtons_RegisterNotify_Ordinal = 0x9a78d6400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kButtons_RegisterNotify_GenOrdinal = 0x1166530aab1f618blu;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsRegisterNotifyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsRegisterNotifyResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kButtons_OnNotify_Ordinal = 0x5affb3b600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kButtons_OnNotify_GenOrdinal = 0x5cdd3f9d680dc674lu;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsOnNotifyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsOnNotifyEventTable;
+
+} // namespace
+template <>
+Buttons::ResultOf::GetState_Impl<Buttons::GetStateResponse>::GetState_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::buttons::ButtonType type) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStateRequest*>(_write_bytes);
+ _request.type = std::move(type);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStateRequest));
+ ::fidl::DecodedMessage<GetStateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Buttons::InPlace::GetState(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Buttons::ResultOf::GetState Buttons::SyncClient::GetState(::llcpp::fuchsia::buttons::ButtonType type) {
+ return ResultOf::GetState(::zx::unowned_channel(this->channel_), std::move(type));
+}
+
+Buttons::ResultOf::GetState Buttons::Call::GetState(::zx::unowned_channel _client_end, ::llcpp::fuchsia::buttons::ButtonType type) {
+ return ResultOf::GetState(std::move(_client_end), std::move(type));
+}
+
+template <>
+Buttons::UnownedResultOf::GetState_Impl<Buttons::GetStateResponse>::GetState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::buttons::ButtonType type, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetStateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetStateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetStateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStateRequest*>(_request_buffer.data());
+ _request.type = std::move(type);
+ _request_buffer.set_actual(sizeof(GetStateRequest));
+ ::fidl::DecodedMessage<GetStateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Buttons::InPlace::GetState(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Buttons::UnownedResultOf::GetState Buttons::SyncClient::GetState(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::buttons::ButtonType type, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetState(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(_response_buffer));
+}
+
+Buttons::UnownedResultOf::GetState Buttons::Call::GetState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::buttons::ButtonType type, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetState(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Buttons::GetStateResponse> Buttons::InPlace::GetState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStateRequest> params, ::fidl::BytePart response_buffer) {
+ Buttons::SetTransactionHeaderFor::GetStateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Buttons::GetStateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStateRequest, GetStateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Buttons::GetStateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Buttons::ResultOf::RegisterNotify_Impl<Buttons::RegisterNotifyResponse>::RegisterNotify_Impl(::zx::unowned_channel _client_end, uint8_t types) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RegisterNotifyRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RegisterNotifyRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RegisterNotifyRequest*>(_write_bytes);
+ _request.types = std::move(types);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RegisterNotifyRequest));
+ ::fidl::DecodedMessage<RegisterNotifyRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Buttons::InPlace::RegisterNotify(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Buttons::ResultOf::RegisterNotify Buttons::SyncClient::RegisterNotify(uint8_t types) {
+ return ResultOf::RegisterNotify(::zx::unowned_channel(this->channel_), std::move(types));
+}
+
+Buttons::ResultOf::RegisterNotify Buttons::Call::RegisterNotify(::zx::unowned_channel _client_end, uint8_t types) {
+ return ResultOf::RegisterNotify(std::move(_client_end), std::move(types));
+}
+
+template <>
+Buttons::UnownedResultOf::RegisterNotify_Impl<Buttons::RegisterNotifyResponse>::RegisterNotify_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t types, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RegisterNotifyRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RegisterNotifyResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RegisterNotifyRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RegisterNotifyRequest*>(_request_buffer.data());
+ _request.types = std::move(types);
+ _request_buffer.set_actual(sizeof(RegisterNotifyRequest));
+ ::fidl::DecodedMessage<RegisterNotifyRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Buttons::InPlace::RegisterNotify(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Buttons::UnownedResultOf::RegisterNotify Buttons::SyncClient::RegisterNotify(::fidl::BytePart _request_buffer, uint8_t types, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RegisterNotify(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(types), std::move(_response_buffer));
+}
+
+Buttons::UnownedResultOf::RegisterNotify Buttons::Call::RegisterNotify(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t types, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RegisterNotify(std::move(_client_end), std::move(_request_buffer), std::move(types), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Buttons::RegisterNotifyResponse> Buttons::InPlace::RegisterNotify(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RegisterNotifyRequest> params, ::fidl::BytePart response_buffer) {
+ Buttons::SetTransactionHeaderFor::RegisterNotifyRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Buttons::RegisterNotifyResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RegisterNotifyRequest, RegisterNotifyResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Buttons::RegisterNotifyResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Buttons::SyncClient::HandleEvents(Buttons::EventHandlers handlers) {
+ return Buttons::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Buttons::Call::HandleEvents(::zx::unowned_channel client_end, Buttons::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnNotifyResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnNotifyResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnNotifyResponse::MaxNumHandles >= x) {
+ x = OnNotifyResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kButtons_OnNotify_Ordinal:
+ case kButtons_OnNotify_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnNotifyResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_notify(std::move(message->type), std::move(message->pressed));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Buttons::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kButtons_GetState_Ordinal:
+ case kButtons_GetState_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetState(std::move(message->type),
+ Interface::GetStateCompleter::Sync(txn));
+ return true;
+ }
+ case kButtons_RegisterNotify_Ordinal:
+ case kButtons_RegisterNotify_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RegisterNotifyRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RegisterNotify(std::move(message->types),
+ Interface::RegisterNotifyCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Buttons::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Buttons::Interface::GetStateCompleterBase::Reply(bool pressed) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetStateResponse*>(_write_bytes);
+ Buttons::SetTransactionHeaderFor::GetStateResponse(
+ ::fidl::DecodedMessage<GetStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateResponse::PrimarySize,
+ GetStateResponse::PrimarySize)));
+ _response.pressed = std::move(pressed);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetStateResponse>(std::move(_response_bytes)));
+}
+
+void Buttons::Interface::GetStateCompleterBase::Reply(::fidl::BytePart _buffer, bool pressed) {
+ if (_buffer.capacity() < GetStateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetStateResponse*>(_buffer.data());
+ Buttons::SetTransactionHeaderFor::GetStateResponse(
+ ::fidl::DecodedMessage<GetStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateResponse::PrimarySize,
+ GetStateResponse::PrimarySize)));
+ _response.pressed = std::move(pressed);
+ _buffer.set_actual(sizeof(GetStateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetStateResponse>(std::move(_buffer)));
+}
+
+void Buttons::Interface::GetStateCompleterBase::Reply(::fidl::DecodedMessage<GetStateResponse> params) {
+ Buttons::SetTransactionHeaderFor::GetStateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Buttons::Interface::RegisterNotifyCompleterBase::Reply(::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RegisterNotifyResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ RegisterNotifyResponse _response = {};
+ Buttons::SetTransactionHeaderFor::RegisterNotifyResponse(
+ ::fidl::DecodedMessage<RegisterNotifyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RegisterNotifyResponse::PrimarySize,
+ RegisterNotifyResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Buttons::Interface::RegisterNotifyCompleterBase::ReplySuccess() {
+ Buttons_RegisterNotify_Response response;
+
+ Reply(Buttons_RegisterNotify_Result::WithResponse(&response));
+}
+void Buttons::Interface::RegisterNotifyCompleterBase::ReplyError(int32_t error) {
+ Reply(Buttons_RegisterNotify_Result::WithErr(&error));
+}
+
+void Buttons::Interface::RegisterNotifyCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Result result) {
+ if (_buffer.capacity() < RegisterNotifyResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RegisterNotifyResponse _response = {};
+ Buttons::SetTransactionHeaderFor::RegisterNotifyResponse(
+ ::fidl::DecodedMessage<RegisterNotifyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RegisterNotifyResponse::PrimarySize,
+ RegisterNotifyResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Buttons::Interface::RegisterNotifyCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Buttons_RegisterNotify_Response response;
+
+ Reply(std::move(_buffer), Buttons_RegisterNotify_Result::WithResponse(&response));
+}
+
+void Buttons::Interface::RegisterNotifyCompleterBase::Reply(::fidl::DecodedMessage<RegisterNotifyResponse> params) {
+ Buttons::SetTransactionHeaderFor::RegisterNotifyResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Buttons::SendOnNotifyEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::buttons::ButtonType type, bool pressed) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnNotifyResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<OnNotifyResponse*>(_write_bytes);
+ Buttons::SetTransactionHeaderFor::OnNotifyResponse(
+ ::fidl::DecodedMessage<OnNotifyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnNotifyResponse::PrimarySize,
+ OnNotifyResponse::PrimarySize)));
+ _response.type = std::move(type);
+ _response.pressed = std::move(pressed);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnNotifyResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<OnNotifyResponse>(std::move(_response_bytes)));
+}
+
+zx_status_t Buttons::SendOnNotifyEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::buttons::ButtonType type, bool pressed) {
+ if (_buffer.capacity() < OnNotifyResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ auto& _response = *reinterpret_cast<OnNotifyResponse*>(_buffer.data());
+ Buttons::SetTransactionHeaderFor::OnNotifyResponse(
+ ::fidl::DecodedMessage<OnNotifyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnNotifyResponse::PrimarySize,
+ OnNotifyResponse::PrimarySize)));
+ _response.type = std::move(type);
+ _response.pressed = std::move(pressed);
+ _buffer.set_actual(sizeof(OnNotifyResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<OnNotifyResponse>(std::move(_buffer)));
+}
+
+zx_status_t Buttons::SendOnNotifyEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnNotifyResponse> params) {
+ Buttons::SetTransactionHeaderFor::OnNotifyResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+
+void Buttons::SetTransactionHeaderFor::GetStateRequest(const ::fidl::DecodedMessage<Buttons::GetStateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kButtons_GetState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Buttons::SetTransactionHeaderFor::GetStateResponse(const ::fidl::DecodedMessage<Buttons::GetStateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kButtons_GetState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Buttons::SetTransactionHeaderFor::RegisterNotifyRequest(const ::fidl::DecodedMessage<Buttons::RegisterNotifyRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kButtons_RegisterNotify_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Buttons::SetTransactionHeaderFor::RegisterNotifyResponse(const ::fidl::DecodedMessage<Buttons::RegisterNotifyResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kButtons_RegisterNotify_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Buttons::SetTransactionHeaderFor::OnNotifyResponse(const ::fidl::DecodedMessage<Buttons::OnNotifyResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kButtons_OnNotify_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace buttons
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-buttons/gen/llcpp/include/fuchsia/buttons/llcpp/fidl.h b/zircon/system/fidl/fuchsia-buttons/gen/llcpp/include/fuchsia/buttons/llcpp/fidl.h
new file mode 100644
index 0000000..a98f403
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-buttons/gen/llcpp/include/fuchsia/buttons/llcpp/fidl.h
@@ -0,0 +1,594 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace buttons {
+
+struct Buttons_RegisterNotify_Response;
+struct Buttons_RegisterNotify_Result;
+enum class ButtonType : uint8_t {
+ VOLUME_UP = 0u,
+ VOLUME_DOWN = 1u,
+ RESET = 2u,
+ MUTE = 3u,
+ MAX = 4u,
+};
+
+
+class Buttons;
+
+extern "C" const fidl_type_t v1_fuchsia_buttons_Buttons_RegisterNotify_ResultTable;
+
+struct Buttons_RegisterNotify_Result {
+ Buttons_RegisterNotify_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Buttons_RegisterNotify_Result WithResponse(::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response* val) {
+ Buttons_RegisterNotify_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Buttons_RegisterNotify_Result WithErr(int32_t* val) {
+ Buttons_RegisterNotify_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_buttons_Buttons_RegisterNotify_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_buttons_Buttons_RegisterNotify_ResponseTable;
+
+struct Buttons_RegisterNotify_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_buttons_Buttons_RegisterNotify_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsGetStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsGetStateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsRegisterNotifyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsRegisterNotifyResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsOnNotifyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_buttons_ButtonsOnNotifyEventTable;
+
+// Protocol for other devices to get the state of buttons and register for
+// notifications of state change.
+class Buttons final {
+ Buttons() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.buttons.Buttons";
+
+ struct GetStateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool pressed;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_buttons_ButtonsGetStateResponseTable;
+ 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 GetStateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::buttons::ButtonType type;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_buttons_ButtonsGetStateRequestTable;
+ 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 = GetStateResponse;
+ };
+
+ struct RegisterNotifyResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_buttons_ButtonsRegisterNotifyResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RegisterNotifyRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint8_t types;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_buttons_ButtonsRegisterNotifyRequestTable;
+ 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 = RegisterNotifyResponse;
+ };
+
+ struct OnNotifyResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::buttons::ButtonType type;
+ bool pressed;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_buttons_ButtonsOnNotifyEventTable;
+ 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 EventHandlers {
+ // Notify event. Called when state of previously registered button changes.
+ // |type| : Button type.
+ // |pressed| : True if button is pressed.
+ fit::callback<zx_status_t(::llcpp::fuchsia::buttons::ButtonType type, bool pressed)> on_notify;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetState_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::buttons::ButtonType type);
+ ~GetState_Impl() = default;
+ GetState_Impl(GetState_Impl&& other) = default;
+ GetState_Impl& operator=(GetState_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 RegisterNotify_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RegisterNotify_Impl(::zx::unowned_channel _client_end, uint8_t types);
+ ~RegisterNotify_Impl() = default;
+ RegisterNotify_Impl(RegisterNotify_Impl&& other) = default;
+ RegisterNotify_Impl& operator=(RegisterNotify_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 GetState = GetState_Impl<GetStateResponse>;
+ using RegisterNotify = RegisterNotify_Impl<RegisterNotifyResponse>;
+ };
+
+ // 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 GetState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::buttons::ButtonType type, ::fidl::BytePart _response_buffer);
+ ~GetState_Impl() = default;
+ GetState_Impl(GetState_Impl&& other) = default;
+ GetState_Impl& operator=(GetState_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 RegisterNotify_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RegisterNotify_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t types, ::fidl::BytePart _response_buffer);
+ ~RegisterNotify_Impl() = default;
+ RegisterNotify_Impl(RegisterNotify_Impl&& other) = default;
+ RegisterNotify_Impl& operator=(RegisterNotify_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 GetState = GetState_Impl<GetStateResponse>;
+ using RegisterNotify = RegisterNotify_Impl<RegisterNotifyResponse>;
+ };
+
+ 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_; }
+
+ // Gets the state of the button requested.
+ // |type| : Button type.
+ // @Returns: |pressed| : True if button is pressed.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetState GetState(::llcpp::fuchsia::buttons::ButtonType type);
+
+ // Gets the state of the button requested.
+ // |type| : Button type.
+ // @Returns: |pressed| : True if button is pressed.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetState GetState(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::buttons::ButtonType type, ::fidl::BytePart _response_buffer);
+
+ // Registers to receive notifications of a state change for some buttons.
+ // |types| : Bitmask which indicates the interested buttons. 0 means not
+ // interested, 1 means interested. Bit position corresponds to
+ // ButtonType, e.g. (1 << VOLUME_UP) means notify only when
+ // the state of the VOLUME_UP button changes. Types not listed
+ // in subsequent calls are removed.
+ // @Returns: |status| : ZX_OK if succeeds.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RegisterNotify RegisterNotify(uint8_t types);
+
+ // Registers to receive notifications of a state change for some buttons.
+ // |types| : Bitmask which indicates the interested buttons. 0 means not
+ // interested, 1 means interested. Bit position corresponds to
+ // ButtonType, e.g. (1 << VOLUME_UP) means notify only when
+ // the state of the VOLUME_UP button changes. Types not listed
+ // in subsequent calls are removed.
+ // @Returns: |status| : ZX_OK if succeeds.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RegisterNotify RegisterNotify(::fidl::BytePart _request_buffer, uint8_t types, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Gets the state of the button requested.
+ // |type| : Button type.
+ // @Returns: |pressed| : True if button is pressed.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetState GetState(::zx::unowned_channel _client_end, ::llcpp::fuchsia::buttons::ButtonType type);
+
+ // Gets the state of the button requested.
+ // |type| : Button type.
+ // @Returns: |pressed| : True if button is pressed.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetState GetState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::buttons::ButtonType type, ::fidl::BytePart _response_buffer);
+
+ // Registers to receive notifications of a state change for some buttons.
+ // |types| : Bitmask which indicates the interested buttons. 0 means not
+ // interested, 1 means interested. Bit position corresponds to
+ // ButtonType, e.g. (1 << VOLUME_UP) means notify only when
+ // the state of the VOLUME_UP button changes. Types not listed
+ // in subsequent calls are removed.
+ // @Returns: |status| : ZX_OK if succeeds.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RegisterNotify RegisterNotify(::zx::unowned_channel _client_end, uint8_t types);
+
+ // Registers to receive notifications of a state change for some buttons.
+ // |types| : Bitmask which indicates the interested buttons. 0 means not
+ // interested, 1 means interested. Bit position corresponds to
+ // ButtonType, e.g. (1 << VOLUME_UP) means notify only when
+ // the state of the VOLUME_UP button changes. Types not listed
+ // in subsequent calls are removed.
+ // @Returns: |status| : ZX_OK if succeeds.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RegisterNotify RegisterNotify(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t types, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Gets the state of the button requested.
+ // |type| : Button type.
+ // @Returns: |pressed| : True if button is pressed.
+ static ::fidl::DecodeResult<GetStateResponse> GetState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStateRequest> params, ::fidl::BytePart response_buffer);
+
+ // Registers to receive notifications of a state change for some buttons.
+ // |types| : Bitmask which indicates the interested buttons. 0 means not
+ // interested, 1 means interested. Bit position corresponds to
+ // ButtonType, e.g. (1 << VOLUME_UP) means notify only when
+ // the state of the VOLUME_UP button changes. Types not listed
+ // in subsequent calls are removed.
+ // @Returns: |status| : ZX_OK if succeeds.
+ static ::fidl::DecodeResult<RegisterNotifyResponse> RegisterNotify(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RegisterNotifyRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Buttons;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetStateCompleterBase : public _Base {
+ public:
+ void Reply(bool pressed);
+ void Reply(::fidl::BytePart _buffer, bool pressed);
+ void Reply(::fidl::DecodedMessage<GetStateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetStateCompleter = ::fidl::Completer<GetStateCompleterBase>;
+
+ virtual void GetState(::llcpp::fuchsia::buttons::ButtonType type, GetStateCompleter::Sync _completer) = 0;
+
+ class RegisterNotifyCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<RegisterNotifyResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RegisterNotifyCompleter = ::fidl::Completer<RegisterNotifyCompleterBase>;
+
+ virtual void RegisterNotify(uint8_t types, RegisterNotifyCompleter::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);
+ }
+
+ // Notify event. Called when state of previously registered button changes.
+ // |type| : Button type.
+ // |pressed| : True if button is pressed.
+ static zx_status_t SendOnNotifyEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::buttons::ButtonType type, bool pressed);
+
+ // Notify event. Called when state of previously registered button changes.
+ // |type| : Button type.
+ // |pressed| : True if button is pressed.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnNotifyEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::buttons::ButtonType type, bool pressed);
+
+ // Notify event. Called when state of previously registered button changes.
+ // |type| : Button type.
+ // |pressed| : True if button is pressed.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnNotifyEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnNotifyResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void GetStateRequest(const ::fidl::DecodedMessage<Buttons::GetStateRequest>& _msg);
+ static void GetStateResponse(const ::fidl::DecodedMessage<Buttons::GetStateResponse>& _msg);
+ static void RegisterNotifyRequest(const ::fidl::DecodedMessage<Buttons::RegisterNotifyRequest>& _msg);
+ static void RegisterNotifyResponse(const ::fidl::DecodedMessage<Buttons::RegisterNotifyResponse>& _msg);
+ static void OnNotifyResponse(const ::fidl::DecodedMessage<Buttons::OnNotifyResponse>& _msg);
+ };
+};
+
+} // namespace buttons
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response>);
+static_assert(offsetof(::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response) == ::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::buttons::Buttons_RegisterNotify_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::buttons::Buttons::GetStateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::buttons::Buttons::GetStateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::buttons::Buttons::GetStateRequest)
+ == ::llcpp::fuchsia::buttons::Buttons::GetStateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::buttons::Buttons::GetStateRequest, type) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::buttons::Buttons::GetStateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::buttons::Buttons::GetStateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::buttons::Buttons::GetStateResponse)
+ == ::llcpp::fuchsia::buttons::Buttons::GetStateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::buttons::Buttons::GetStateResponse, pressed) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::buttons::Buttons::RegisterNotifyRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::buttons::Buttons::RegisterNotifyRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::buttons::Buttons::RegisterNotifyRequest)
+ == ::llcpp::fuchsia::buttons::Buttons::RegisterNotifyRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::buttons::Buttons::RegisterNotifyRequest, types) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::buttons::Buttons::RegisterNotifyResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::buttons::Buttons::RegisterNotifyResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::buttons::Buttons::RegisterNotifyResponse)
+ == ::llcpp::fuchsia::buttons::Buttons::RegisterNotifyResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::buttons::Buttons::RegisterNotifyResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::buttons::Buttons::OnNotifyResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::buttons::Buttons::OnNotifyResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::buttons::Buttons::OnNotifyResponse)
+ == ::llcpp::fuchsia::buttons::Buttons::OnNotifyResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::buttons::Buttons::OnNotifyResponse, type) == 16);
+static_assert(offsetof(::llcpp::fuchsia::buttons::Buttons::OnNotifyResponse, pressed) == 17);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-cobalt/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-cobalt/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..9dc3dcb
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-cobalt/gen/llcpp/fidl.cc
@@ -0,0 +1,5285 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/cobalt/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace cobalt {
+
+void ::llcpp::fuchsia::cobalt::Value::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Value) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Value, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Value, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kController_RequestSendSoon_Ordinal = 0x8d7092700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_RequestSendSoon_GenOrdinal = 0x554e66bab8f72e3dlu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerRequestSendSoonRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerRequestSendSoonResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_BlockUntilEmpty_Ordinal = 0x2bf57e3200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_BlockUntilEmpty_GenOrdinal = 0x72bcf7dd29d1cd5alu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerBlockUntilEmptyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerBlockUntilEmptyResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetNumSendAttempts_Ordinal = 0x5805f03f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetNumSendAttempts_GenOrdinal = 0x7ec5409cbc36c796lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetNumSendAttemptsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetNumSendAttemptsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetFailedSendAttempts_Ordinal = 0x3a378f4700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetFailedSendAttempts_GenOrdinal = 0x5c5af723b6a5067lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetFailedSendAttemptsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetFailedSendAttemptsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetNumObservationsAdded_Ordinal = 0x2889cd4500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetNumObservationsAdded_GenOrdinal = 0x2f568da2a6cf0ec5lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetNumObservationsAddedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetNumObservationsAddedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GenerateAggregatedObservations_Ordinal = 0x5ad64bce00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GenerateAggregatedObservations_GenOrdinal = 0x79e058c9497f1ab1lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGenerateAggregatedObservationsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGenerateAggregatedObservationsResponseTable;
+
+} // namespace
+template <>
+Controller::ResultOf::RequestSendSoon_Impl<Controller::RequestSendSoonResponse>::RequestSendSoon_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RequestSendSoonRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RequestSendSoonRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RequestSendSoonRequest));
+ ::fidl::DecodedMessage<RequestSendSoonRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::RequestSendSoon(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::RequestSendSoon Controller::SyncClient::RequestSendSoon() {
+ return ResultOf::RequestSendSoon(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::RequestSendSoon Controller::Call::RequestSendSoon(::zx::unowned_channel _client_end) {
+ return ResultOf::RequestSendSoon(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::RequestSendSoon_Impl<Controller::RequestSendSoonResponse>::RequestSendSoon_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RequestSendSoonRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, RequestSendSoonRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(RequestSendSoonRequest));
+ ::fidl::DecodedMessage<RequestSendSoonRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::RequestSendSoon(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::RequestSendSoon Controller::SyncClient::RequestSendSoon(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RequestSendSoon(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::RequestSendSoon Controller::Call::RequestSendSoon(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RequestSendSoon(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::RequestSendSoonResponse> Controller::InPlace::RequestSendSoon(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(RequestSendSoonRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<RequestSendSoonRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::RequestSendSoonRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::RequestSendSoonResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RequestSendSoonRequest, RequestSendSoonResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::RequestSendSoonResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::BlockUntilEmpty_Impl<Controller::BlockUntilEmptyResponse>::BlockUntilEmpty_Impl(::zx::unowned_channel _client_end, uint32_t max_wait_seconds) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BlockUntilEmptyRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, BlockUntilEmptyRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<BlockUntilEmptyRequest*>(_write_bytes);
+ _request.max_wait_seconds = std::move(max_wait_seconds);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(BlockUntilEmptyRequest));
+ ::fidl::DecodedMessage<BlockUntilEmptyRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::BlockUntilEmpty(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::BlockUntilEmpty Controller::SyncClient::BlockUntilEmpty(uint32_t max_wait_seconds) {
+ return ResultOf::BlockUntilEmpty(::zx::unowned_channel(this->channel_), std::move(max_wait_seconds));
+}
+
+Controller::ResultOf::BlockUntilEmpty Controller::Call::BlockUntilEmpty(::zx::unowned_channel _client_end, uint32_t max_wait_seconds) {
+ return ResultOf::BlockUntilEmpty(std::move(_client_end), std::move(max_wait_seconds));
+}
+
+template <>
+Controller::UnownedResultOf::BlockUntilEmpty_Impl<Controller::BlockUntilEmptyResponse>::BlockUntilEmpty_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t max_wait_seconds, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BlockUntilEmptyRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BlockUntilEmptyResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, BlockUntilEmptyRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<BlockUntilEmptyRequest*>(_request_buffer.data());
+ _request.max_wait_seconds = std::move(max_wait_seconds);
+ _request_buffer.set_actual(sizeof(BlockUntilEmptyRequest));
+ ::fidl::DecodedMessage<BlockUntilEmptyRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::BlockUntilEmpty(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::BlockUntilEmpty Controller::SyncClient::BlockUntilEmpty(::fidl::BytePart _request_buffer, uint32_t max_wait_seconds, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::BlockUntilEmpty(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(max_wait_seconds), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::BlockUntilEmpty Controller::Call::BlockUntilEmpty(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t max_wait_seconds, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::BlockUntilEmpty(std::move(_client_end), std::move(_request_buffer), std::move(max_wait_seconds), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::BlockUntilEmptyResponse> Controller::InPlace::BlockUntilEmpty(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BlockUntilEmptyRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::BlockUntilEmptyRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::BlockUntilEmptyResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BlockUntilEmptyRequest, BlockUntilEmptyResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::BlockUntilEmptyResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetNumSendAttempts_Impl<Controller::GetNumSendAttemptsResponse>::GetNumSendAttempts_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNumSendAttemptsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNumSendAttemptsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNumSendAttemptsRequest));
+ ::fidl::DecodedMessage<GetNumSendAttemptsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetNumSendAttempts(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetNumSendAttempts Controller::SyncClient::GetNumSendAttempts() {
+ return ResultOf::GetNumSendAttempts(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetNumSendAttempts Controller::Call::GetNumSendAttempts(::zx::unowned_channel _client_end) {
+ return ResultOf::GetNumSendAttempts(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetNumSendAttempts_Impl<Controller::GetNumSendAttemptsResponse>::GetNumSendAttempts_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNumSendAttemptsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetNumSendAttemptsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetNumSendAttemptsRequest));
+ ::fidl::DecodedMessage<GetNumSendAttemptsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetNumSendAttempts(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetNumSendAttempts Controller::SyncClient::GetNumSendAttempts(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNumSendAttempts(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetNumSendAttempts Controller::Call::GetNumSendAttempts(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNumSendAttempts(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetNumSendAttemptsResponse> Controller::InPlace::GetNumSendAttempts(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetNumSendAttemptsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetNumSendAttemptsRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetNumSendAttemptsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetNumSendAttemptsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNumSendAttemptsRequest, GetNumSendAttemptsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetNumSendAttemptsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetFailedSendAttempts_Impl<Controller::GetFailedSendAttemptsResponse>::GetFailedSendAttempts_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFailedSendAttemptsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFailedSendAttemptsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFailedSendAttemptsRequest));
+ ::fidl::DecodedMessage<GetFailedSendAttemptsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetFailedSendAttempts(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetFailedSendAttempts Controller::SyncClient::GetFailedSendAttempts() {
+ return ResultOf::GetFailedSendAttempts(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetFailedSendAttempts Controller::Call::GetFailedSendAttempts(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFailedSendAttempts(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetFailedSendAttempts_Impl<Controller::GetFailedSendAttemptsResponse>::GetFailedSendAttempts_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFailedSendAttemptsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFailedSendAttemptsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFailedSendAttemptsRequest));
+ ::fidl::DecodedMessage<GetFailedSendAttemptsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetFailedSendAttempts(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetFailedSendAttempts Controller::SyncClient::GetFailedSendAttempts(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFailedSendAttempts(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetFailedSendAttempts Controller::Call::GetFailedSendAttempts(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFailedSendAttempts(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetFailedSendAttemptsResponse> Controller::InPlace::GetFailedSendAttempts(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFailedSendAttemptsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFailedSendAttemptsRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetFailedSendAttemptsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetFailedSendAttemptsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFailedSendAttemptsRequest, GetFailedSendAttemptsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetFailedSendAttemptsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetNumObservationsAdded_Impl<Controller::GetNumObservationsAddedResponse>::GetNumObservationsAdded_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNumObservationsAddedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNumObservationsAddedRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNumObservationsAddedRequest));
+ ::fidl::DecodedMessage<GetNumObservationsAddedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetNumObservationsAdded(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetNumObservationsAdded Controller::SyncClient::GetNumObservationsAdded() {
+ return ResultOf::GetNumObservationsAdded(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetNumObservationsAdded Controller::Call::GetNumObservationsAdded(::zx::unowned_channel _client_end) {
+ return ResultOf::GetNumObservationsAdded(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetNumObservationsAdded_Impl<Controller::GetNumObservationsAddedResponse>::GetNumObservationsAdded_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNumObservationsAddedRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetNumObservationsAddedRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetNumObservationsAddedRequest));
+ ::fidl::DecodedMessage<GetNumObservationsAddedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetNumObservationsAdded(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetNumObservationsAdded Controller::SyncClient::GetNumObservationsAdded(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNumObservationsAdded(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetNumObservationsAdded Controller::Call::GetNumObservationsAdded(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNumObservationsAdded(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetNumObservationsAddedResponse> Controller::InPlace::GetNumObservationsAdded(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetNumObservationsAddedRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetNumObservationsAddedRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetNumObservationsAddedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetNumObservationsAddedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNumObservationsAddedRequest, GetNumObservationsAddedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetNumObservationsAddedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GenerateAggregatedObservations_Impl<Controller::GenerateAggregatedObservationsResponse>::GenerateAggregatedObservations_Impl(::zx::unowned_channel _client_end, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GenerateAggregatedObservationsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ GenerateAggregatedObservationsRequest _request = {};
+ _request.day_index = std::move(day_index);
+ _request.report_ids = std::move(report_ids);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<GenerateAggregatedObservationsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Controller::InPlace::GenerateAggregatedObservations(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::GenerateAggregatedObservations Controller::SyncClient::GenerateAggregatedObservations(uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids) {
+ return ResultOf::GenerateAggregatedObservations(::zx::unowned_channel(this->channel_), std::move(day_index), std::move(report_ids));
+}
+
+Controller::ResultOf::GenerateAggregatedObservations Controller::Call::GenerateAggregatedObservations(::zx::unowned_channel _client_end, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids) {
+ return ResultOf::GenerateAggregatedObservations(std::move(_client_end), std::move(day_index), std::move(report_ids));
+}
+
+template <>
+Controller::UnownedResultOf::GenerateAggregatedObservations_Impl<Controller::GenerateAggregatedObservationsResponse>::GenerateAggregatedObservations_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GenerateAggregatedObservationsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GenerateAggregatedObservationsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ GenerateAggregatedObservationsRequest _request = {};
+ _request.day_index = std::move(day_index);
+ _request.report_ids = std::move(report_ids);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<GenerateAggregatedObservationsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Controller::InPlace::GenerateAggregatedObservations(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GenerateAggregatedObservations Controller::SyncClient::GenerateAggregatedObservations(::fidl::BytePart _request_buffer, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GenerateAggregatedObservations(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(day_index), std::move(report_ids), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GenerateAggregatedObservations Controller::Call::GenerateAggregatedObservations(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GenerateAggregatedObservations(std::move(_client_end), std::move(_request_buffer), std::move(day_index), std::move(report_ids), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GenerateAggregatedObservationsResponse> Controller::InPlace::GenerateAggregatedObservations(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GenerateAggregatedObservationsRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::GenerateAggregatedObservationsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GenerateAggregatedObservationsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GenerateAggregatedObservationsRequest, GenerateAggregatedObservationsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GenerateAggregatedObservationsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Controller::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kController_RequestSendSoon_Ordinal:
+ case kController_RequestSendSoon_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RequestSendSoonRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->RequestSendSoon(
+ Interface::RequestSendSoonCompleter::Sync(txn));
+ return true;
+ }
+ case kController_BlockUntilEmpty_Ordinal:
+ case kController_BlockUntilEmpty_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BlockUntilEmptyRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->BlockUntilEmpty(std::move(message->max_wait_seconds),
+ Interface::BlockUntilEmptyCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetNumSendAttempts_Ordinal:
+ case kController_GetNumSendAttempts_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNumSendAttemptsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetNumSendAttempts(
+ Interface::GetNumSendAttemptsCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetFailedSendAttempts_Ordinal:
+ case kController_GetFailedSendAttempts_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFailedSendAttemptsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFailedSendAttempts(
+ Interface::GetFailedSendAttemptsCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetNumObservationsAdded_Ordinal:
+ case kController_GetNumObservationsAdded_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNumObservationsAddedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetNumObservationsAdded(
+ Interface::GetNumObservationsAddedCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GenerateAggregatedObservations_Ordinal:
+ case kController_GenerateAggregatedObservations_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GenerateAggregatedObservationsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GenerateAggregatedObservations(std::move(message->day_index), std::move(message->report_ids),
+ Interface::GenerateAggregatedObservationsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Controller::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Controller::Interface::RequestSendSoonCompleterBase::Reply(bool success) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RequestSendSoonResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RequestSendSoonResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::RequestSendSoonResponse(
+ ::fidl::DecodedMessage<RequestSendSoonResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RequestSendSoonResponse::PrimarySize,
+ RequestSendSoonResponse::PrimarySize)));
+ _response.success = std::move(success);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RequestSendSoonResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RequestSendSoonResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::RequestSendSoonCompleterBase::Reply(::fidl::BytePart _buffer, bool success) {
+ if (_buffer.capacity() < RequestSendSoonResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RequestSendSoonResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::RequestSendSoonResponse(
+ ::fidl::DecodedMessage<RequestSendSoonResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RequestSendSoonResponse::PrimarySize,
+ RequestSendSoonResponse::PrimarySize)));
+ _response.success = std::move(success);
+ _buffer.set_actual(sizeof(RequestSendSoonResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RequestSendSoonResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::RequestSendSoonCompleterBase::Reply(::fidl::DecodedMessage<RequestSendSoonResponse> params) {
+ Controller::SetTransactionHeaderFor::RequestSendSoonResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::BlockUntilEmptyCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BlockUntilEmptyResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<BlockUntilEmptyResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::BlockUntilEmptyResponse(
+ ::fidl::DecodedMessage<BlockUntilEmptyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BlockUntilEmptyResponse::PrimarySize,
+ BlockUntilEmptyResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(BlockUntilEmptyResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<BlockUntilEmptyResponse>(std::move(_response_bytes)));
+}
+
+
+void Controller::Interface::GetNumSendAttemptsCompleterBase::Reply(uint32_t num) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNumSendAttemptsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetNumSendAttemptsResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetNumSendAttemptsResponse(
+ ::fidl::DecodedMessage<GetNumSendAttemptsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNumSendAttemptsResponse::PrimarySize,
+ GetNumSendAttemptsResponse::PrimarySize)));
+ _response.num = std::move(num);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNumSendAttemptsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetNumSendAttemptsResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetNumSendAttemptsCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t num) {
+ if (_buffer.capacity() < GetNumSendAttemptsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetNumSendAttemptsResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetNumSendAttemptsResponse(
+ ::fidl::DecodedMessage<GetNumSendAttemptsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNumSendAttemptsResponse::PrimarySize,
+ GetNumSendAttemptsResponse::PrimarySize)));
+ _response.num = std::move(num);
+ _buffer.set_actual(sizeof(GetNumSendAttemptsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetNumSendAttemptsResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetNumSendAttemptsCompleterBase::Reply(::fidl::DecodedMessage<GetNumSendAttemptsResponse> params) {
+ Controller::SetTransactionHeaderFor::GetNumSendAttemptsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetFailedSendAttemptsCompleterBase::Reply(uint32_t num) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFailedSendAttemptsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetFailedSendAttemptsResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetFailedSendAttemptsResponse(
+ ::fidl::DecodedMessage<GetFailedSendAttemptsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFailedSendAttemptsResponse::PrimarySize,
+ GetFailedSendAttemptsResponse::PrimarySize)));
+ _response.num = std::move(num);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFailedSendAttemptsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFailedSendAttemptsResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetFailedSendAttemptsCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t num) {
+ if (_buffer.capacity() < GetFailedSendAttemptsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetFailedSendAttemptsResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetFailedSendAttemptsResponse(
+ ::fidl::DecodedMessage<GetFailedSendAttemptsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFailedSendAttemptsResponse::PrimarySize,
+ GetFailedSendAttemptsResponse::PrimarySize)));
+ _response.num = std::move(num);
+ _buffer.set_actual(sizeof(GetFailedSendAttemptsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFailedSendAttemptsResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetFailedSendAttemptsCompleterBase::Reply(::fidl::DecodedMessage<GetFailedSendAttemptsResponse> params) {
+ Controller::SetTransactionHeaderFor::GetFailedSendAttemptsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetNumObservationsAddedCompleterBase::Reply(uint64_t num_obs) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNumObservationsAddedResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetNumObservationsAddedResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetNumObservationsAddedResponse(
+ ::fidl::DecodedMessage<GetNumObservationsAddedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNumObservationsAddedResponse::PrimarySize,
+ GetNumObservationsAddedResponse::PrimarySize)));
+ _response.num_obs = std::move(num_obs);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNumObservationsAddedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetNumObservationsAddedResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetNumObservationsAddedCompleterBase::Reply(::fidl::BytePart _buffer, uint64_t num_obs) {
+ if (_buffer.capacity() < GetNumObservationsAddedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetNumObservationsAddedResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetNumObservationsAddedResponse(
+ ::fidl::DecodedMessage<GetNumObservationsAddedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNumObservationsAddedResponse::PrimarySize,
+ GetNumObservationsAddedResponse::PrimarySize)));
+ _response.num_obs = std::move(num_obs);
+ _buffer.set_actual(sizeof(GetNumObservationsAddedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetNumObservationsAddedResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetNumObservationsAddedCompleterBase::Reply(::fidl::DecodedMessage<GetNumObservationsAddedResponse> params) {
+ Controller::SetTransactionHeaderFor::GetNumObservationsAddedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GenerateAggregatedObservationsCompleterBase::Reply(::fidl::VectorView<uint64_t> num_obs) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GenerateAggregatedObservationsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GenerateAggregatedObservationsResponse _response = {};
+ Controller::SetTransactionHeaderFor::GenerateAggregatedObservationsResponse(
+ ::fidl::DecodedMessage<GenerateAggregatedObservationsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GenerateAggregatedObservationsResponse::PrimarySize,
+ GenerateAggregatedObservationsResponse::PrimarySize)));
+ _response.num_obs = std::move(num_obs);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GenerateAggregatedObservationsCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<uint64_t> num_obs) {
+ if (_buffer.capacity() < GenerateAggregatedObservationsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GenerateAggregatedObservationsResponse _response = {};
+ Controller::SetTransactionHeaderFor::GenerateAggregatedObservationsResponse(
+ ::fidl::DecodedMessage<GenerateAggregatedObservationsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GenerateAggregatedObservationsResponse::PrimarySize,
+ GenerateAggregatedObservationsResponse::PrimarySize)));
+ _response.num_obs = std::move(num_obs);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GenerateAggregatedObservationsCompleterBase::Reply(::fidl::DecodedMessage<GenerateAggregatedObservationsResponse> params) {
+ Controller::SetTransactionHeaderFor::GenerateAggregatedObservationsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Controller::SetTransactionHeaderFor::RequestSendSoonRequest(const ::fidl::DecodedMessage<Controller::RequestSendSoonRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_RequestSendSoon_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::RequestSendSoonResponse(const ::fidl::DecodedMessage<Controller::RequestSendSoonResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_RequestSendSoon_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::BlockUntilEmptyRequest(const ::fidl::DecodedMessage<Controller::BlockUntilEmptyRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_BlockUntilEmpty_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::BlockUntilEmptyResponse(const ::fidl::DecodedMessage<Controller::BlockUntilEmptyResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_BlockUntilEmpty_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetNumSendAttemptsRequest(const ::fidl::DecodedMessage<Controller::GetNumSendAttemptsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetNumSendAttempts_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetNumSendAttemptsResponse(const ::fidl::DecodedMessage<Controller::GetNumSendAttemptsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetNumSendAttempts_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetFailedSendAttemptsRequest(const ::fidl::DecodedMessage<Controller::GetFailedSendAttemptsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetFailedSendAttempts_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetFailedSendAttemptsResponse(const ::fidl::DecodedMessage<Controller::GetFailedSendAttemptsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetFailedSendAttempts_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetNumObservationsAddedRequest(const ::fidl::DecodedMessage<Controller::GetNumObservationsAddedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetNumObservationsAdded_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetNumObservationsAddedResponse(const ::fidl::DecodedMessage<Controller::GetNumObservationsAddedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetNumObservationsAdded_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GenerateAggregatedObservationsRequest(const ::fidl::DecodedMessage<Controller::GenerateAggregatedObservationsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GenerateAggregatedObservations_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GenerateAggregatedObservationsResponse(const ::fidl::DecodedMessage<Controller::GenerateAggregatedObservationsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GenerateAggregatedObservations_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogEvent_Ordinal = 0x135d628d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogEvent_GenOrdinal = 0x293433df480dd41elu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogEventCount_Ordinal = 0x6fce776500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogEventCount_GenOrdinal = 0x5f73f8b900d4bbb1lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogEventCountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogEventCountResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogElapsedTime_Ordinal = 0x14f4912000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogElapsedTime_GenOrdinal = 0x42e58931fd6c785lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogElapsedTimeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogElapsedTimeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogFrameRate_Ordinal = 0x2b8722b800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogFrameRate_GenOrdinal = 0x4c701bca4836097lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogFrameRateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogFrameRateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogMemoryUsage_Ordinal = 0x66c69d1b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_LogMemoryUsage_GenOrdinal = 0x14189c11cc19d641lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogMemoryUsageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogMemoryUsageResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_StartTimer_Ordinal = 0x4a5c612000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_StartTimer_GenOrdinal = 0x68cec08d094e4938lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseStartTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseStartTimerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_EndTimer_Ordinal = 0x65db6e4200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerBase_EndTimer_GenOrdinal = 0xf0043bc7ed4b561lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseEndTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseEndTimerResponseTable;
+
+} // namespace
+template <>
+LoggerBase::ResultOf::LogEvent_Impl<LoggerBase::LogEventResponse>::LogEvent_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, LogEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<LogEventRequest*>(_write_bytes);
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventRequest));
+ ::fidl::DecodedMessage<LogEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ LoggerBase::InPlace::LogEvent(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerBase::ResultOf::LogEvent LoggerBase::SyncClient::LogEvent(uint32_t metric_id, uint32_t event_code) {
+ return ResultOf::LogEvent(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code));
+}
+
+LoggerBase::ResultOf::LogEvent LoggerBase::Call::LogEvent(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code) {
+ return ResultOf::LogEvent(std::move(_client_end), std::move(metric_id), std::move(event_code));
+}
+
+template <>
+LoggerBase::UnownedResultOf::LogEvent_Impl<LoggerBase::LogEventResponse>::LogEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogEventRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogEventResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, LogEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<LogEventRequest*>(_request_buffer.data());
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request_buffer.set_actual(sizeof(LogEventRequest));
+ ::fidl::DecodedMessage<LogEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ LoggerBase::InPlace::LogEvent(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerBase::UnownedResultOf::LogEvent LoggerBase::SyncClient::LogEvent(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEvent(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(_response_buffer));
+}
+
+LoggerBase::UnownedResultOf::LogEvent LoggerBase::Call::LogEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEvent(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerBase::LogEventResponse> LoggerBase::InPlace::LogEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerBase::SetTransactionHeaderFor::LogEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogEventRequest, LogEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerBase::ResultOf::LogEventCount_Impl<LoggerBase::LogEventCountResponse>::LogEventCount_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventCountRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogEventCountRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.period_duration_micros = std::move(period_duration_micros);
+ _request.count = std::move(count);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogEventCountRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::LogEventCount(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerBase::ResultOf::LogEventCount LoggerBase::SyncClient::LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ return ResultOf::LogEventCount(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count));
+}
+
+LoggerBase::ResultOf::LogEventCount LoggerBase::Call::LogEventCount(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ return ResultOf::LogEventCount(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count));
+}
+
+template <>
+LoggerBase::UnownedResultOf::LogEventCount_Impl<LoggerBase::LogEventCountResponse>::LogEventCount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogEventCountRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogEventCountResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogEventCountRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.period_duration_micros = std::move(period_duration_micros);
+ _request.count = std::move(count);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogEventCountRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::LogEventCount(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerBase::UnownedResultOf::LogEventCount LoggerBase::SyncClient::LogEventCount(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEventCount(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count), std::move(_response_buffer));
+}
+
+LoggerBase::UnownedResultOf::LogEventCount LoggerBase::Call::LogEventCount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEventCount(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerBase::LogEventCountResponse> LoggerBase::InPlace::LogEventCount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventCountRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerBase::SetTransactionHeaderFor::LogEventCountRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogEventCountResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogEventCountRequest, LogEventCountResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogEventCountResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerBase::ResultOf::LogElapsedTime_Impl<LoggerBase::LogElapsedTimeResponse>::LogElapsedTime_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogElapsedTimeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogElapsedTimeRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.elapsed_micros = std::move(elapsed_micros);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogElapsedTimeRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::LogElapsedTime(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerBase::ResultOf::LogElapsedTime LoggerBase::SyncClient::LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ return ResultOf::LogElapsedTime(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros));
+}
+
+LoggerBase::ResultOf::LogElapsedTime LoggerBase::Call::LogElapsedTime(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ return ResultOf::LogElapsedTime(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros));
+}
+
+template <>
+LoggerBase::UnownedResultOf::LogElapsedTime_Impl<LoggerBase::LogElapsedTimeResponse>::LogElapsedTime_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogElapsedTimeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogElapsedTimeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogElapsedTimeRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.elapsed_micros = std::move(elapsed_micros);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogElapsedTimeRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::LogElapsedTime(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerBase::UnownedResultOf::LogElapsedTime LoggerBase::SyncClient::LogElapsedTime(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogElapsedTime(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros), std::move(_response_buffer));
+}
+
+LoggerBase::UnownedResultOf::LogElapsedTime LoggerBase::Call::LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogElapsedTime(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerBase::LogElapsedTimeResponse> LoggerBase::InPlace::LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogElapsedTimeRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerBase::SetTransactionHeaderFor::LogElapsedTimeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogElapsedTimeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogElapsedTimeRequest, LogElapsedTimeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogElapsedTimeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerBase::ResultOf::LogFrameRate_Impl<LoggerBase::LogFrameRateResponse>::LogFrameRate_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogFrameRateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogFrameRateRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.fps = std::move(fps);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogFrameRateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::LogFrameRate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerBase::ResultOf::LogFrameRate LoggerBase::SyncClient::LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ return ResultOf::LogFrameRate(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps));
+}
+
+LoggerBase::ResultOf::LogFrameRate LoggerBase::Call::LogFrameRate(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ return ResultOf::LogFrameRate(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps));
+}
+
+template <>
+LoggerBase::UnownedResultOf::LogFrameRate_Impl<LoggerBase::LogFrameRateResponse>::LogFrameRate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogFrameRateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogFrameRateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogFrameRateRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.fps = std::move(fps);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogFrameRateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::LogFrameRate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerBase::UnownedResultOf::LogFrameRate LoggerBase::SyncClient::LogFrameRate(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogFrameRate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps), std::move(_response_buffer));
+}
+
+LoggerBase::UnownedResultOf::LogFrameRate LoggerBase::Call::LogFrameRate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogFrameRate(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerBase::LogFrameRateResponse> LoggerBase::InPlace::LogFrameRate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogFrameRateRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerBase::SetTransactionHeaderFor::LogFrameRateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogFrameRateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogFrameRateRequest, LogFrameRateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogFrameRateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerBase::ResultOf::LogMemoryUsage_Impl<LoggerBase::LogMemoryUsageResponse>::LogMemoryUsage_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogMemoryUsageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogMemoryUsageRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.bytes = std::move(bytes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogMemoryUsageRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::LogMemoryUsage(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerBase::ResultOf::LogMemoryUsage LoggerBase::SyncClient::LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ return ResultOf::LogMemoryUsage(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes));
+}
+
+LoggerBase::ResultOf::LogMemoryUsage LoggerBase::Call::LogMemoryUsage(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ return ResultOf::LogMemoryUsage(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes));
+}
+
+template <>
+LoggerBase::UnownedResultOf::LogMemoryUsage_Impl<LoggerBase::LogMemoryUsageResponse>::LogMemoryUsage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogMemoryUsageRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogMemoryUsageResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogMemoryUsageRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.bytes = std::move(bytes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogMemoryUsageRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::LogMemoryUsage(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerBase::UnownedResultOf::LogMemoryUsage LoggerBase::SyncClient::LogMemoryUsage(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogMemoryUsage(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes), std::move(_response_buffer));
+}
+
+LoggerBase::UnownedResultOf::LogMemoryUsage LoggerBase::Call::LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogMemoryUsage(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerBase::LogMemoryUsageResponse> LoggerBase::InPlace::LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogMemoryUsageRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerBase::SetTransactionHeaderFor::LogMemoryUsageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogMemoryUsageResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogMemoryUsageRequest, LogMemoryUsageResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::LogMemoryUsageResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerBase::ResultOf::StartTimer_Impl<LoggerBase::StartTimerResponse>::StartTimer_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartTimerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ StartTimerRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<StartTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::StartTimer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerBase::ResultOf::StartTimer LoggerBase::SyncClient::StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::StartTimer(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+LoggerBase::ResultOf::StartTimer LoggerBase::Call::StartTimer(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::StartTimer(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+template <>
+LoggerBase::UnownedResultOf::StartTimer_Impl<LoggerBase::StartTimerResponse>::StartTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < StartTimerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<StartTimerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ StartTimerRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<StartTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::StartTimer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerBase::UnownedResultOf::StartTimer LoggerBase::SyncClient::StartTimer(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StartTimer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+LoggerBase::UnownedResultOf::StartTimer LoggerBase::Call::StartTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StartTimer(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerBase::StartTimerResponse> LoggerBase::InPlace::StartTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StartTimerRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerBase::SetTransactionHeaderFor::StartTimerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::StartTimerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StartTimerRequest, StartTimerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::StartTimerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerBase::ResultOf::EndTimer_Impl<LoggerBase::EndTimerResponse>::EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EndTimerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ EndTimerRequest _request = {};
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EndTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::EndTimer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerBase::ResultOf::EndTimer LoggerBase::SyncClient::EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::EndTimer(::zx::unowned_channel(this->channel_), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+LoggerBase::ResultOf::EndTimer LoggerBase::Call::EndTimer(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::EndTimer(std::move(_client_end), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+template <>
+LoggerBase::UnownedResultOf::EndTimer_Impl<LoggerBase::EndTimerResponse>::EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < EndTimerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<EndTimerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ EndTimerRequest _request = {};
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EndTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerBase::InPlace::EndTimer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerBase::UnownedResultOf::EndTimer LoggerBase::SyncClient::EndTimer(::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EndTimer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+LoggerBase::UnownedResultOf::EndTimer LoggerBase::Call::EndTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EndTimer(std::move(_client_end), std::move(_request_buffer), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerBase::EndTimerResponse> LoggerBase::InPlace::EndTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EndTimerRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerBase::SetTransactionHeaderFor::EndTimerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::EndTimerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<EndTimerRequest, EndTimerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerBase::EndTimerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool LoggerBase::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kLoggerBase_LogEvent_Ordinal:
+ case kLoggerBase_LogEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogEvent(std::move(message->metric_id), std::move(message->event_code),
+ Interface::LogEventCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerBase_LogEventCount_Ordinal:
+ case kLoggerBase_LogEventCount_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogEventCountRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogEventCount(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->period_duration_micros), std::move(message->count),
+ Interface::LogEventCountCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerBase_LogElapsedTime_Ordinal:
+ case kLoggerBase_LogElapsedTime_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogElapsedTimeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogElapsedTime(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->elapsed_micros),
+ Interface::LogElapsedTimeCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerBase_LogFrameRate_Ordinal:
+ case kLoggerBase_LogFrameRate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogFrameRateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogFrameRate(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->fps),
+ Interface::LogFrameRateCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerBase_LogMemoryUsage_Ordinal:
+ case kLoggerBase_LogMemoryUsage_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogMemoryUsageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogMemoryUsage(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->bytes),
+ Interface::LogMemoryUsageCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerBase_StartTimer_Ordinal:
+ case kLoggerBase_StartTimer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StartTimerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->StartTimer(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->timer_id), std::move(message->timestamp), std::move(message->timeout_s),
+ Interface::StartTimerCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerBase_EndTimer_Ordinal:
+ case kLoggerBase_EndTimer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EndTimerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->EndTimer(std::move(message->timer_id), std::move(message->timestamp), std::move(message->timeout_s),
+ Interface::EndTimerCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool LoggerBase::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void LoggerBase::Interface::LogEventCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogEventResponse*>(_write_bytes);
+ LoggerBase::SetTransactionHeaderFor::LogEventResponse(
+ ::fidl::DecodedMessage<LogEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventResponse::PrimarySize,
+ LogEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventResponse>(std::move(_response_bytes)));
+}
+
+void LoggerBase::Interface::LogEventCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogEventResponse*>(_buffer.data());
+ LoggerBase::SetTransactionHeaderFor::LogEventResponse(
+ ::fidl::DecodedMessage<LogEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventResponse::PrimarySize,
+ LogEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventResponse>(std::move(_buffer)));
+}
+
+void LoggerBase::Interface::LogEventCompleterBase::Reply(::fidl::DecodedMessage<LogEventResponse> params) {
+ LoggerBase::SetTransactionHeaderFor::LogEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerBase::Interface::LogEventCountCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventCountResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogEventCountResponse*>(_write_bytes);
+ LoggerBase::SetTransactionHeaderFor::LogEventCountResponse(
+ ::fidl::DecodedMessage<LogEventCountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventCountResponse::PrimarySize,
+ LogEventCountResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventCountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventCountResponse>(std::move(_response_bytes)));
+}
+
+void LoggerBase::Interface::LogEventCountCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogEventCountResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogEventCountResponse*>(_buffer.data());
+ LoggerBase::SetTransactionHeaderFor::LogEventCountResponse(
+ ::fidl::DecodedMessage<LogEventCountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventCountResponse::PrimarySize,
+ LogEventCountResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogEventCountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventCountResponse>(std::move(_buffer)));
+}
+
+void LoggerBase::Interface::LogEventCountCompleterBase::Reply(::fidl::DecodedMessage<LogEventCountResponse> params) {
+ LoggerBase::SetTransactionHeaderFor::LogEventCountResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerBase::Interface::LogElapsedTimeCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogElapsedTimeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogElapsedTimeResponse*>(_write_bytes);
+ LoggerBase::SetTransactionHeaderFor::LogElapsedTimeResponse(
+ ::fidl::DecodedMessage<LogElapsedTimeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogElapsedTimeResponse::PrimarySize,
+ LogElapsedTimeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogElapsedTimeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogElapsedTimeResponse>(std::move(_response_bytes)));
+}
+
+void LoggerBase::Interface::LogElapsedTimeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogElapsedTimeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogElapsedTimeResponse*>(_buffer.data());
+ LoggerBase::SetTransactionHeaderFor::LogElapsedTimeResponse(
+ ::fidl::DecodedMessage<LogElapsedTimeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogElapsedTimeResponse::PrimarySize,
+ LogElapsedTimeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogElapsedTimeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogElapsedTimeResponse>(std::move(_buffer)));
+}
+
+void LoggerBase::Interface::LogElapsedTimeCompleterBase::Reply(::fidl::DecodedMessage<LogElapsedTimeResponse> params) {
+ LoggerBase::SetTransactionHeaderFor::LogElapsedTimeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerBase::Interface::LogFrameRateCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogFrameRateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogFrameRateResponse*>(_write_bytes);
+ LoggerBase::SetTransactionHeaderFor::LogFrameRateResponse(
+ ::fidl::DecodedMessage<LogFrameRateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogFrameRateResponse::PrimarySize,
+ LogFrameRateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogFrameRateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogFrameRateResponse>(std::move(_response_bytes)));
+}
+
+void LoggerBase::Interface::LogFrameRateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogFrameRateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogFrameRateResponse*>(_buffer.data());
+ LoggerBase::SetTransactionHeaderFor::LogFrameRateResponse(
+ ::fidl::DecodedMessage<LogFrameRateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogFrameRateResponse::PrimarySize,
+ LogFrameRateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogFrameRateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogFrameRateResponse>(std::move(_buffer)));
+}
+
+void LoggerBase::Interface::LogFrameRateCompleterBase::Reply(::fidl::DecodedMessage<LogFrameRateResponse> params) {
+ LoggerBase::SetTransactionHeaderFor::LogFrameRateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerBase::Interface::LogMemoryUsageCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogMemoryUsageResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogMemoryUsageResponse*>(_write_bytes);
+ LoggerBase::SetTransactionHeaderFor::LogMemoryUsageResponse(
+ ::fidl::DecodedMessage<LogMemoryUsageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogMemoryUsageResponse::PrimarySize,
+ LogMemoryUsageResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogMemoryUsageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogMemoryUsageResponse>(std::move(_response_bytes)));
+}
+
+void LoggerBase::Interface::LogMemoryUsageCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogMemoryUsageResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogMemoryUsageResponse*>(_buffer.data());
+ LoggerBase::SetTransactionHeaderFor::LogMemoryUsageResponse(
+ ::fidl::DecodedMessage<LogMemoryUsageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogMemoryUsageResponse::PrimarySize,
+ LogMemoryUsageResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogMemoryUsageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogMemoryUsageResponse>(std::move(_buffer)));
+}
+
+void LoggerBase::Interface::LogMemoryUsageCompleterBase::Reply(::fidl::DecodedMessage<LogMemoryUsageResponse> params) {
+ LoggerBase::SetTransactionHeaderFor::LogMemoryUsageResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerBase::Interface::StartTimerCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartTimerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StartTimerResponse*>(_write_bytes);
+ LoggerBase::SetTransactionHeaderFor::StartTimerResponse(
+ ::fidl::DecodedMessage<StartTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartTimerResponse::PrimarySize,
+ StartTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartTimerResponse>(std::move(_response_bytes)));
+}
+
+void LoggerBase::Interface::StartTimerCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < StartTimerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<StartTimerResponse*>(_buffer.data());
+ LoggerBase::SetTransactionHeaderFor::StartTimerResponse(
+ ::fidl::DecodedMessage<StartTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartTimerResponse::PrimarySize,
+ StartTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(StartTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartTimerResponse>(std::move(_buffer)));
+}
+
+void LoggerBase::Interface::StartTimerCompleterBase::Reply(::fidl::DecodedMessage<StartTimerResponse> params) {
+ LoggerBase::SetTransactionHeaderFor::StartTimerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerBase::Interface::EndTimerCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EndTimerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<EndTimerResponse*>(_write_bytes);
+ LoggerBase::SetTransactionHeaderFor::EndTimerResponse(
+ ::fidl::DecodedMessage<EndTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EndTimerResponse::PrimarySize,
+ EndTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(EndTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EndTimerResponse>(std::move(_response_bytes)));
+}
+
+void LoggerBase::Interface::EndTimerCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < EndTimerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<EndTimerResponse*>(_buffer.data());
+ LoggerBase::SetTransactionHeaderFor::EndTimerResponse(
+ ::fidl::DecodedMessage<EndTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EndTimerResponse::PrimarySize,
+ EndTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(EndTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EndTimerResponse>(std::move(_buffer)));
+}
+
+void LoggerBase::Interface::EndTimerCompleterBase::Reply(::fidl::DecodedMessage<EndTimerResponse> params) {
+ LoggerBase::SetTransactionHeaderFor::EndTimerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void LoggerBase::SetTransactionHeaderFor::LogEventRequest(const ::fidl::DecodedMessage<LoggerBase::LogEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerBase::SetTransactionHeaderFor::LogEventResponse(const ::fidl::DecodedMessage<LoggerBase::LogEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerBase::SetTransactionHeaderFor::LogEventCountRequest(const ::fidl::DecodedMessage<LoggerBase::LogEventCountRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogEventCount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerBase::SetTransactionHeaderFor::LogEventCountResponse(const ::fidl::DecodedMessage<LoggerBase::LogEventCountResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogEventCount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerBase::SetTransactionHeaderFor::LogElapsedTimeRequest(const ::fidl::DecodedMessage<LoggerBase::LogElapsedTimeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogElapsedTime_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerBase::SetTransactionHeaderFor::LogElapsedTimeResponse(const ::fidl::DecodedMessage<LoggerBase::LogElapsedTimeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogElapsedTime_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerBase::SetTransactionHeaderFor::LogFrameRateRequest(const ::fidl::DecodedMessage<LoggerBase::LogFrameRateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogFrameRate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerBase::SetTransactionHeaderFor::LogFrameRateResponse(const ::fidl::DecodedMessage<LoggerBase::LogFrameRateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogFrameRate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerBase::SetTransactionHeaderFor::LogMemoryUsageRequest(const ::fidl::DecodedMessage<LoggerBase::LogMemoryUsageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogMemoryUsage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerBase::SetTransactionHeaderFor::LogMemoryUsageResponse(const ::fidl::DecodedMessage<LoggerBase::LogMemoryUsageResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_LogMemoryUsage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerBase::SetTransactionHeaderFor::StartTimerRequest(const ::fidl::DecodedMessage<LoggerBase::StartTimerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_StartTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerBase::SetTransactionHeaderFor::StartTimerResponse(const ::fidl::DecodedMessage<LoggerBase::StartTimerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_StartTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerBase::SetTransactionHeaderFor::EndTimerRequest(const ::fidl::DecodedMessage<LoggerBase::EndTimerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_EndTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerBase::SetTransactionHeaderFor::EndTimerResponse(const ::fidl::DecodedMessage<LoggerBase::EndTimerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerBase_EndTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogEvent_Ordinal = 0x135d628d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogEvent_GenOrdinal = 0x293433df480dd41elu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogEventCount_Ordinal = 0x6fce776500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogEventCount_GenOrdinal = 0x5f73f8b900d4bbb1lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogEventCountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogEventCountResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogElapsedTime_Ordinal = 0x14f4912000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogElapsedTime_GenOrdinal = 0x42e58931fd6c785lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogElapsedTimeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogElapsedTimeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogFrameRate_Ordinal = 0x2b8722b800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogFrameRate_GenOrdinal = 0x4c701bca4836097lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogFrameRateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogFrameRateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogMemoryUsage_Ordinal = 0x66c69d1b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogMemoryUsage_GenOrdinal = 0x14189c11cc19d641lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogMemoryUsageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogMemoryUsageResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_StartTimer_Ordinal = 0x4a5c612000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_StartTimer_GenOrdinal = 0x68cec08d094e4938lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleStartTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleStartTimerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_EndTimer_Ordinal = 0x65db6e4200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_EndTimer_GenOrdinal = 0xf0043bc7ed4b561lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleEndTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleEndTimerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogIntHistogram_Ordinal = 0x2d40524800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerSimple_LogIntHistogram_GenOrdinal = 0x7edf09f7389af401lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogIntHistogramRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogIntHistogramResponseTable;
+
+} // namespace
+template <>
+LoggerSimple::ResultOf::LogEvent_Impl<LoggerSimple::LogEventResponse>::LogEvent_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, LogEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<LogEventRequest*>(_write_bytes);
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventRequest));
+ ::fidl::DecodedMessage<LogEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ LoggerSimple::InPlace::LogEvent(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerSimple::ResultOf::LogEvent LoggerSimple::SyncClient::LogEvent(uint32_t metric_id, uint32_t event_code) {
+ return ResultOf::LogEvent(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code));
+}
+
+LoggerSimple::ResultOf::LogEvent LoggerSimple::Call::LogEvent(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code) {
+ return ResultOf::LogEvent(std::move(_client_end), std::move(metric_id), std::move(event_code));
+}
+
+template <>
+LoggerSimple::UnownedResultOf::LogEvent_Impl<LoggerSimple::LogEventResponse>::LogEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogEventRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogEventResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, LogEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<LogEventRequest*>(_request_buffer.data());
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request_buffer.set_actual(sizeof(LogEventRequest));
+ ::fidl::DecodedMessage<LogEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ LoggerSimple::InPlace::LogEvent(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerSimple::UnownedResultOf::LogEvent LoggerSimple::SyncClient::LogEvent(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEvent(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(_response_buffer));
+}
+
+LoggerSimple::UnownedResultOf::LogEvent LoggerSimple::Call::LogEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEvent(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerSimple::LogEventResponse> LoggerSimple::InPlace::LogEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerSimple::SetTransactionHeaderFor::LogEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogEventRequest, LogEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerSimple::ResultOf::LogEventCount_Impl<LoggerSimple::LogEventCountResponse>::LogEventCount_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventCountRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogEventCountRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.period_duration_micros = std::move(period_duration_micros);
+ _request.count = std::move(count);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogEventCountRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogEventCount(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerSimple::ResultOf::LogEventCount LoggerSimple::SyncClient::LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ return ResultOf::LogEventCount(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count));
+}
+
+LoggerSimple::ResultOf::LogEventCount LoggerSimple::Call::LogEventCount(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ return ResultOf::LogEventCount(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count));
+}
+
+template <>
+LoggerSimple::UnownedResultOf::LogEventCount_Impl<LoggerSimple::LogEventCountResponse>::LogEventCount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogEventCountRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogEventCountResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogEventCountRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.period_duration_micros = std::move(period_duration_micros);
+ _request.count = std::move(count);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogEventCountRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogEventCount(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerSimple::UnownedResultOf::LogEventCount LoggerSimple::SyncClient::LogEventCount(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEventCount(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count), std::move(_response_buffer));
+}
+
+LoggerSimple::UnownedResultOf::LogEventCount LoggerSimple::Call::LogEventCount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEventCount(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerSimple::LogEventCountResponse> LoggerSimple::InPlace::LogEventCount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventCountRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerSimple::SetTransactionHeaderFor::LogEventCountRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogEventCountResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogEventCountRequest, LogEventCountResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogEventCountResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerSimple::ResultOf::LogElapsedTime_Impl<LoggerSimple::LogElapsedTimeResponse>::LogElapsedTime_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogElapsedTimeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogElapsedTimeRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.elapsed_micros = std::move(elapsed_micros);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogElapsedTimeRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogElapsedTime(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerSimple::ResultOf::LogElapsedTime LoggerSimple::SyncClient::LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ return ResultOf::LogElapsedTime(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros));
+}
+
+LoggerSimple::ResultOf::LogElapsedTime LoggerSimple::Call::LogElapsedTime(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ return ResultOf::LogElapsedTime(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros));
+}
+
+template <>
+LoggerSimple::UnownedResultOf::LogElapsedTime_Impl<LoggerSimple::LogElapsedTimeResponse>::LogElapsedTime_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogElapsedTimeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogElapsedTimeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogElapsedTimeRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.elapsed_micros = std::move(elapsed_micros);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogElapsedTimeRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogElapsedTime(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerSimple::UnownedResultOf::LogElapsedTime LoggerSimple::SyncClient::LogElapsedTime(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogElapsedTime(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros), std::move(_response_buffer));
+}
+
+LoggerSimple::UnownedResultOf::LogElapsedTime LoggerSimple::Call::LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogElapsedTime(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerSimple::LogElapsedTimeResponse> LoggerSimple::InPlace::LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogElapsedTimeRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerSimple::SetTransactionHeaderFor::LogElapsedTimeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogElapsedTimeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogElapsedTimeRequest, LogElapsedTimeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogElapsedTimeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerSimple::ResultOf::LogFrameRate_Impl<LoggerSimple::LogFrameRateResponse>::LogFrameRate_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogFrameRateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogFrameRateRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.fps = std::move(fps);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogFrameRateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogFrameRate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerSimple::ResultOf::LogFrameRate LoggerSimple::SyncClient::LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ return ResultOf::LogFrameRate(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps));
+}
+
+LoggerSimple::ResultOf::LogFrameRate LoggerSimple::Call::LogFrameRate(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ return ResultOf::LogFrameRate(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps));
+}
+
+template <>
+LoggerSimple::UnownedResultOf::LogFrameRate_Impl<LoggerSimple::LogFrameRateResponse>::LogFrameRate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogFrameRateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogFrameRateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogFrameRateRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.fps = std::move(fps);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogFrameRateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogFrameRate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerSimple::UnownedResultOf::LogFrameRate LoggerSimple::SyncClient::LogFrameRate(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogFrameRate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps), std::move(_response_buffer));
+}
+
+LoggerSimple::UnownedResultOf::LogFrameRate LoggerSimple::Call::LogFrameRate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogFrameRate(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerSimple::LogFrameRateResponse> LoggerSimple::InPlace::LogFrameRate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogFrameRateRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerSimple::SetTransactionHeaderFor::LogFrameRateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogFrameRateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogFrameRateRequest, LogFrameRateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogFrameRateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerSimple::ResultOf::LogMemoryUsage_Impl<LoggerSimple::LogMemoryUsageResponse>::LogMemoryUsage_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogMemoryUsageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogMemoryUsageRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.bytes = std::move(bytes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogMemoryUsageRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogMemoryUsage(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerSimple::ResultOf::LogMemoryUsage LoggerSimple::SyncClient::LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ return ResultOf::LogMemoryUsage(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes));
+}
+
+LoggerSimple::ResultOf::LogMemoryUsage LoggerSimple::Call::LogMemoryUsage(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ return ResultOf::LogMemoryUsage(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes));
+}
+
+template <>
+LoggerSimple::UnownedResultOf::LogMemoryUsage_Impl<LoggerSimple::LogMemoryUsageResponse>::LogMemoryUsage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogMemoryUsageRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogMemoryUsageResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogMemoryUsageRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.bytes = std::move(bytes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogMemoryUsageRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogMemoryUsage(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerSimple::UnownedResultOf::LogMemoryUsage LoggerSimple::SyncClient::LogMemoryUsage(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogMemoryUsage(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes), std::move(_response_buffer));
+}
+
+LoggerSimple::UnownedResultOf::LogMemoryUsage LoggerSimple::Call::LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogMemoryUsage(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerSimple::LogMemoryUsageResponse> LoggerSimple::InPlace::LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogMemoryUsageRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerSimple::SetTransactionHeaderFor::LogMemoryUsageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogMemoryUsageResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogMemoryUsageRequest, LogMemoryUsageResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogMemoryUsageResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerSimple::ResultOf::StartTimer_Impl<LoggerSimple::StartTimerResponse>::StartTimer_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartTimerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ StartTimerRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<StartTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::StartTimer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerSimple::ResultOf::StartTimer LoggerSimple::SyncClient::StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::StartTimer(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+LoggerSimple::ResultOf::StartTimer LoggerSimple::Call::StartTimer(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::StartTimer(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+template <>
+LoggerSimple::UnownedResultOf::StartTimer_Impl<LoggerSimple::StartTimerResponse>::StartTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < StartTimerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<StartTimerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ StartTimerRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<StartTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::StartTimer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerSimple::UnownedResultOf::StartTimer LoggerSimple::SyncClient::StartTimer(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StartTimer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+LoggerSimple::UnownedResultOf::StartTimer LoggerSimple::Call::StartTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StartTimer(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerSimple::StartTimerResponse> LoggerSimple::InPlace::StartTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StartTimerRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerSimple::SetTransactionHeaderFor::StartTimerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::StartTimerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StartTimerRequest, StartTimerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::StartTimerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerSimple::ResultOf::EndTimer_Impl<LoggerSimple::EndTimerResponse>::EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EndTimerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ EndTimerRequest _request = {};
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EndTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::EndTimer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerSimple::ResultOf::EndTimer LoggerSimple::SyncClient::EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::EndTimer(::zx::unowned_channel(this->channel_), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+LoggerSimple::ResultOf::EndTimer LoggerSimple::Call::EndTimer(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::EndTimer(std::move(_client_end), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+template <>
+LoggerSimple::UnownedResultOf::EndTimer_Impl<LoggerSimple::EndTimerResponse>::EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < EndTimerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<EndTimerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ EndTimerRequest _request = {};
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EndTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::EndTimer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerSimple::UnownedResultOf::EndTimer LoggerSimple::SyncClient::EndTimer(::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EndTimer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+LoggerSimple::UnownedResultOf::EndTimer LoggerSimple::Call::EndTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EndTimer(std::move(_client_end), std::move(_request_buffer), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerSimple::EndTimerResponse> LoggerSimple::InPlace::EndTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EndTimerRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerSimple::SetTransactionHeaderFor::EndTimerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::EndTimerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<EndTimerRequest, EndTimerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::EndTimerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerSimple::ResultOf::LogIntHistogram_Impl<LoggerSimple::LogIntHistogramResponse>::LogIntHistogram_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogIntHistogramRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LogIntHistogramRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.bucket_indices = std::move(bucket_indices);
+ _request.bucket_counts = std::move(bucket_counts);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogIntHistogramRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogIntHistogram(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerSimple::ResultOf::LogIntHistogram LoggerSimple::SyncClient::LogIntHistogram(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts) {
+ return ResultOf::LogIntHistogram(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(bucket_indices), std::move(bucket_counts));
+}
+
+LoggerSimple::ResultOf::LogIntHistogram LoggerSimple::Call::LogIntHistogram(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts) {
+ return ResultOf::LogIntHistogram(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(bucket_indices), std::move(bucket_counts));
+}
+
+template <>
+LoggerSimple::UnownedResultOf::LogIntHistogram_Impl<LoggerSimple::LogIntHistogramResponse>::LogIntHistogram_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogIntHistogramRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogIntHistogramResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogIntHistogramRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.bucket_indices = std::move(bucket_indices);
+ _request.bucket_counts = std::move(bucket_counts);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogIntHistogramRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ LoggerSimple::InPlace::LogIntHistogram(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerSimple::UnownedResultOf::LogIntHistogram LoggerSimple::SyncClient::LogIntHistogram(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogIntHistogram(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(bucket_indices), std::move(bucket_counts), std::move(_response_buffer));
+}
+
+LoggerSimple::UnownedResultOf::LogIntHistogram LoggerSimple::Call::LogIntHistogram(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogIntHistogram(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(bucket_indices), std::move(bucket_counts), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerSimple::LogIntHistogramResponse> LoggerSimple::InPlace::LogIntHistogram(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogIntHistogramRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerSimple::SetTransactionHeaderFor::LogIntHistogramRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogIntHistogramResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogIntHistogramRequest, LogIntHistogramResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerSimple::LogIntHistogramResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool LoggerSimple::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kLoggerSimple_LogEvent_Ordinal:
+ case kLoggerSimple_LogEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogEvent(std::move(message->metric_id), std::move(message->event_code),
+ Interface::LogEventCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerSimple_LogEventCount_Ordinal:
+ case kLoggerSimple_LogEventCount_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogEventCountRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogEventCount(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->period_duration_micros), std::move(message->count),
+ Interface::LogEventCountCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerSimple_LogElapsedTime_Ordinal:
+ case kLoggerSimple_LogElapsedTime_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogElapsedTimeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogElapsedTime(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->elapsed_micros),
+ Interface::LogElapsedTimeCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerSimple_LogFrameRate_Ordinal:
+ case kLoggerSimple_LogFrameRate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogFrameRateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogFrameRate(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->fps),
+ Interface::LogFrameRateCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerSimple_LogMemoryUsage_Ordinal:
+ case kLoggerSimple_LogMemoryUsage_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogMemoryUsageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogMemoryUsage(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->bytes),
+ Interface::LogMemoryUsageCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerSimple_StartTimer_Ordinal:
+ case kLoggerSimple_StartTimer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StartTimerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->StartTimer(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->timer_id), std::move(message->timestamp), std::move(message->timeout_s),
+ Interface::StartTimerCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerSimple_EndTimer_Ordinal:
+ case kLoggerSimple_EndTimer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EndTimerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->EndTimer(std::move(message->timer_id), std::move(message->timestamp), std::move(message->timeout_s),
+ Interface::EndTimerCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerSimple_LogIntHistogram_Ordinal:
+ case kLoggerSimple_LogIntHistogram_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogIntHistogramRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogIntHistogram(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->bucket_indices), std::move(message->bucket_counts),
+ Interface::LogIntHistogramCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool LoggerSimple::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void LoggerSimple::Interface::LogEventCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogEventResponse*>(_write_bytes);
+ LoggerSimple::SetTransactionHeaderFor::LogEventResponse(
+ ::fidl::DecodedMessage<LogEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventResponse::PrimarySize,
+ LogEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventResponse>(std::move(_response_bytes)));
+}
+
+void LoggerSimple::Interface::LogEventCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogEventResponse*>(_buffer.data());
+ LoggerSimple::SetTransactionHeaderFor::LogEventResponse(
+ ::fidl::DecodedMessage<LogEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventResponse::PrimarySize,
+ LogEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventResponse>(std::move(_buffer)));
+}
+
+void LoggerSimple::Interface::LogEventCompleterBase::Reply(::fidl::DecodedMessage<LogEventResponse> params) {
+ LoggerSimple::SetTransactionHeaderFor::LogEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerSimple::Interface::LogEventCountCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventCountResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogEventCountResponse*>(_write_bytes);
+ LoggerSimple::SetTransactionHeaderFor::LogEventCountResponse(
+ ::fidl::DecodedMessage<LogEventCountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventCountResponse::PrimarySize,
+ LogEventCountResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventCountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventCountResponse>(std::move(_response_bytes)));
+}
+
+void LoggerSimple::Interface::LogEventCountCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogEventCountResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogEventCountResponse*>(_buffer.data());
+ LoggerSimple::SetTransactionHeaderFor::LogEventCountResponse(
+ ::fidl::DecodedMessage<LogEventCountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventCountResponse::PrimarySize,
+ LogEventCountResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogEventCountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventCountResponse>(std::move(_buffer)));
+}
+
+void LoggerSimple::Interface::LogEventCountCompleterBase::Reply(::fidl::DecodedMessage<LogEventCountResponse> params) {
+ LoggerSimple::SetTransactionHeaderFor::LogEventCountResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerSimple::Interface::LogElapsedTimeCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogElapsedTimeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogElapsedTimeResponse*>(_write_bytes);
+ LoggerSimple::SetTransactionHeaderFor::LogElapsedTimeResponse(
+ ::fidl::DecodedMessage<LogElapsedTimeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogElapsedTimeResponse::PrimarySize,
+ LogElapsedTimeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogElapsedTimeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogElapsedTimeResponse>(std::move(_response_bytes)));
+}
+
+void LoggerSimple::Interface::LogElapsedTimeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogElapsedTimeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogElapsedTimeResponse*>(_buffer.data());
+ LoggerSimple::SetTransactionHeaderFor::LogElapsedTimeResponse(
+ ::fidl::DecodedMessage<LogElapsedTimeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogElapsedTimeResponse::PrimarySize,
+ LogElapsedTimeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogElapsedTimeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogElapsedTimeResponse>(std::move(_buffer)));
+}
+
+void LoggerSimple::Interface::LogElapsedTimeCompleterBase::Reply(::fidl::DecodedMessage<LogElapsedTimeResponse> params) {
+ LoggerSimple::SetTransactionHeaderFor::LogElapsedTimeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerSimple::Interface::LogFrameRateCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogFrameRateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogFrameRateResponse*>(_write_bytes);
+ LoggerSimple::SetTransactionHeaderFor::LogFrameRateResponse(
+ ::fidl::DecodedMessage<LogFrameRateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogFrameRateResponse::PrimarySize,
+ LogFrameRateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogFrameRateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogFrameRateResponse>(std::move(_response_bytes)));
+}
+
+void LoggerSimple::Interface::LogFrameRateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogFrameRateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogFrameRateResponse*>(_buffer.data());
+ LoggerSimple::SetTransactionHeaderFor::LogFrameRateResponse(
+ ::fidl::DecodedMessage<LogFrameRateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogFrameRateResponse::PrimarySize,
+ LogFrameRateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogFrameRateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogFrameRateResponse>(std::move(_buffer)));
+}
+
+void LoggerSimple::Interface::LogFrameRateCompleterBase::Reply(::fidl::DecodedMessage<LogFrameRateResponse> params) {
+ LoggerSimple::SetTransactionHeaderFor::LogFrameRateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerSimple::Interface::LogMemoryUsageCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogMemoryUsageResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogMemoryUsageResponse*>(_write_bytes);
+ LoggerSimple::SetTransactionHeaderFor::LogMemoryUsageResponse(
+ ::fidl::DecodedMessage<LogMemoryUsageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogMemoryUsageResponse::PrimarySize,
+ LogMemoryUsageResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogMemoryUsageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogMemoryUsageResponse>(std::move(_response_bytes)));
+}
+
+void LoggerSimple::Interface::LogMemoryUsageCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogMemoryUsageResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogMemoryUsageResponse*>(_buffer.data());
+ LoggerSimple::SetTransactionHeaderFor::LogMemoryUsageResponse(
+ ::fidl::DecodedMessage<LogMemoryUsageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogMemoryUsageResponse::PrimarySize,
+ LogMemoryUsageResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogMemoryUsageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogMemoryUsageResponse>(std::move(_buffer)));
+}
+
+void LoggerSimple::Interface::LogMemoryUsageCompleterBase::Reply(::fidl::DecodedMessage<LogMemoryUsageResponse> params) {
+ LoggerSimple::SetTransactionHeaderFor::LogMemoryUsageResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerSimple::Interface::StartTimerCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartTimerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StartTimerResponse*>(_write_bytes);
+ LoggerSimple::SetTransactionHeaderFor::StartTimerResponse(
+ ::fidl::DecodedMessage<StartTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartTimerResponse::PrimarySize,
+ StartTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartTimerResponse>(std::move(_response_bytes)));
+}
+
+void LoggerSimple::Interface::StartTimerCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < StartTimerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<StartTimerResponse*>(_buffer.data());
+ LoggerSimple::SetTransactionHeaderFor::StartTimerResponse(
+ ::fidl::DecodedMessage<StartTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartTimerResponse::PrimarySize,
+ StartTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(StartTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartTimerResponse>(std::move(_buffer)));
+}
+
+void LoggerSimple::Interface::StartTimerCompleterBase::Reply(::fidl::DecodedMessage<StartTimerResponse> params) {
+ LoggerSimple::SetTransactionHeaderFor::StartTimerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerSimple::Interface::EndTimerCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EndTimerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<EndTimerResponse*>(_write_bytes);
+ LoggerSimple::SetTransactionHeaderFor::EndTimerResponse(
+ ::fidl::DecodedMessage<EndTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EndTimerResponse::PrimarySize,
+ EndTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(EndTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EndTimerResponse>(std::move(_response_bytes)));
+}
+
+void LoggerSimple::Interface::EndTimerCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < EndTimerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<EndTimerResponse*>(_buffer.data());
+ LoggerSimple::SetTransactionHeaderFor::EndTimerResponse(
+ ::fidl::DecodedMessage<EndTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EndTimerResponse::PrimarySize,
+ EndTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(EndTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EndTimerResponse>(std::move(_buffer)));
+}
+
+void LoggerSimple::Interface::EndTimerCompleterBase::Reply(::fidl::DecodedMessage<EndTimerResponse> params) {
+ LoggerSimple::SetTransactionHeaderFor::EndTimerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerSimple::Interface::LogIntHistogramCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogIntHistogramResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogIntHistogramResponse*>(_write_bytes);
+ LoggerSimple::SetTransactionHeaderFor::LogIntHistogramResponse(
+ ::fidl::DecodedMessage<LogIntHistogramResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogIntHistogramResponse::PrimarySize,
+ LogIntHistogramResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogIntHistogramResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogIntHistogramResponse>(std::move(_response_bytes)));
+}
+
+void LoggerSimple::Interface::LogIntHistogramCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogIntHistogramResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogIntHistogramResponse*>(_buffer.data());
+ LoggerSimple::SetTransactionHeaderFor::LogIntHistogramResponse(
+ ::fidl::DecodedMessage<LogIntHistogramResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogIntHistogramResponse::PrimarySize,
+ LogIntHistogramResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogIntHistogramResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogIntHistogramResponse>(std::move(_buffer)));
+}
+
+void LoggerSimple::Interface::LogIntHistogramCompleterBase::Reply(::fidl::DecodedMessage<LogIntHistogramResponse> params) {
+ LoggerSimple::SetTransactionHeaderFor::LogIntHistogramResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void LoggerSimple::SetTransactionHeaderFor::LogEventRequest(const ::fidl::DecodedMessage<LoggerSimple::LogEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerSimple::SetTransactionHeaderFor::LogEventResponse(const ::fidl::DecodedMessage<LoggerSimple::LogEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerSimple::SetTransactionHeaderFor::LogEventCountRequest(const ::fidl::DecodedMessage<LoggerSimple::LogEventCountRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogEventCount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerSimple::SetTransactionHeaderFor::LogEventCountResponse(const ::fidl::DecodedMessage<LoggerSimple::LogEventCountResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogEventCount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerSimple::SetTransactionHeaderFor::LogElapsedTimeRequest(const ::fidl::DecodedMessage<LoggerSimple::LogElapsedTimeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogElapsedTime_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerSimple::SetTransactionHeaderFor::LogElapsedTimeResponse(const ::fidl::DecodedMessage<LoggerSimple::LogElapsedTimeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogElapsedTime_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerSimple::SetTransactionHeaderFor::LogFrameRateRequest(const ::fidl::DecodedMessage<LoggerSimple::LogFrameRateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogFrameRate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerSimple::SetTransactionHeaderFor::LogFrameRateResponse(const ::fidl::DecodedMessage<LoggerSimple::LogFrameRateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogFrameRate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerSimple::SetTransactionHeaderFor::LogMemoryUsageRequest(const ::fidl::DecodedMessage<LoggerSimple::LogMemoryUsageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogMemoryUsage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerSimple::SetTransactionHeaderFor::LogMemoryUsageResponse(const ::fidl::DecodedMessage<LoggerSimple::LogMemoryUsageResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogMemoryUsage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerSimple::SetTransactionHeaderFor::StartTimerRequest(const ::fidl::DecodedMessage<LoggerSimple::StartTimerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_StartTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerSimple::SetTransactionHeaderFor::StartTimerResponse(const ::fidl::DecodedMessage<LoggerSimple::StartTimerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_StartTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerSimple::SetTransactionHeaderFor::EndTimerRequest(const ::fidl::DecodedMessage<LoggerSimple::EndTimerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_EndTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerSimple::SetTransactionHeaderFor::EndTimerResponse(const ::fidl::DecodedMessage<LoggerSimple::EndTimerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_EndTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerSimple::SetTransactionHeaderFor::LogIntHistogramRequest(const ::fidl::DecodedMessage<LoggerSimple::LogIntHistogramRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogIntHistogram_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerSimple::SetTransactionHeaderFor::LogIntHistogramResponse(const ::fidl::DecodedMessage<LoggerSimple::LogIntHistogramResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerSimple_LogIntHistogram_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLoggerFactory_CreateLogger_Ordinal = 0x5f08858100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerFactory_CreateLogger_GenOrdinal = 0x2a6a220ee3111ab0lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerFactory_CreateLoggerSimple_Ordinal = 0x5f07c39f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerFactory_CreateLoggerSimple_GenOrdinal = 0x5aa6be2e24fa92f8lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerFactory_CreateLoggerFromProjectId_Ordinal = 0x2b04487500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerFactory_CreateLoggerFromProjectId_GenOrdinal = 0x44ee41845029c9celu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerFromProjectIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerFromProjectIdResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoggerFactory_CreateLoggerSimpleFromProjectId_Ordinal = 0x118ecf3100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoggerFactory_CreateLoggerSimpleFromProjectId_GenOrdinal = 0x1f76f43312ce641flu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleFromProjectIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleFromProjectIdResponseTable;
+
+} // namespace
+template <>
+LoggerFactory::ResultOf::CreateLogger_Impl<LoggerFactory::CreateLoggerResponse>::CreateLogger_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLoggerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CreateLoggerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateLoggerRequest*>(_write_bytes);
+ _request.profile = std::move(profile);
+ _request.logger = std::move(logger);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLoggerRequest));
+ ::fidl::DecodedMessage<CreateLoggerRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ LoggerFactory::InPlace::CreateLogger(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerFactory::ResultOf::CreateLogger LoggerFactory::SyncClient::CreateLogger(::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger) {
+ return ResultOf::CreateLogger(::zx::unowned_channel(this->channel_), std::move(profile), std::move(logger));
+}
+
+LoggerFactory::ResultOf::CreateLogger LoggerFactory::Call::CreateLogger(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger) {
+ return ResultOf::CreateLogger(std::move(_client_end), std::move(profile), std::move(logger));
+}
+
+template <>
+LoggerFactory::UnownedResultOf::CreateLogger_Impl<LoggerFactory::CreateLoggerResponse>::CreateLogger_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CreateLoggerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CreateLoggerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CreateLoggerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateLoggerRequest*>(_request_buffer.data());
+ _request.profile = std::move(profile);
+ _request.logger = std::move(logger);
+ _request_buffer.set_actual(sizeof(CreateLoggerRequest));
+ ::fidl::DecodedMessage<CreateLoggerRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ LoggerFactory::InPlace::CreateLogger(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerFactory::UnownedResultOf::CreateLogger LoggerFactory::SyncClient::CreateLogger(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLogger(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(profile), std::move(logger), std::move(_response_buffer));
+}
+
+LoggerFactory::UnownedResultOf::CreateLogger LoggerFactory::Call::CreateLogger(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLogger(std::move(_client_end), std::move(_request_buffer), std::move(profile), std::move(logger), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerFactory::CreateLoggerResponse> LoggerFactory::InPlace::CreateLogger(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateLoggerRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerFactory::CreateLoggerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CreateLoggerRequest, CreateLoggerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerFactory::CreateLoggerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerFactory::ResultOf::CreateLoggerSimple_Impl<LoggerFactory::CreateLoggerSimpleResponse>::CreateLoggerSimple_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLoggerSimpleRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CreateLoggerSimpleRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateLoggerSimpleRequest*>(_write_bytes);
+ _request.profile = std::move(profile);
+ _request.logger = std::move(logger);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLoggerSimpleRequest));
+ ::fidl::DecodedMessage<CreateLoggerSimpleRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ LoggerFactory::InPlace::CreateLoggerSimple(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerFactory::ResultOf::CreateLoggerSimple LoggerFactory::SyncClient::CreateLoggerSimple(::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger) {
+ return ResultOf::CreateLoggerSimple(::zx::unowned_channel(this->channel_), std::move(profile), std::move(logger));
+}
+
+LoggerFactory::ResultOf::CreateLoggerSimple LoggerFactory::Call::CreateLoggerSimple(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger) {
+ return ResultOf::CreateLoggerSimple(std::move(_client_end), std::move(profile), std::move(logger));
+}
+
+template <>
+LoggerFactory::UnownedResultOf::CreateLoggerSimple_Impl<LoggerFactory::CreateLoggerSimpleResponse>::CreateLoggerSimple_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CreateLoggerSimpleRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CreateLoggerSimpleResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CreateLoggerSimpleRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateLoggerSimpleRequest*>(_request_buffer.data());
+ _request.profile = std::move(profile);
+ _request.logger = std::move(logger);
+ _request_buffer.set_actual(sizeof(CreateLoggerSimpleRequest));
+ ::fidl::DecodedMessage<CreateLoggerSimpleRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ LoggerFactory::InPlace::CreateLoggerSimple(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerFactory::UnownedResultOf::CreateLoggerSimple LoggerFactory::SyncClient::CreateLoggerSimple(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLoggerSimple(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(profile), std::move(logger), std::move(_response_buffer));
+}
+
+LoggerFactory::UnownedResultOf::CreateLoggerSimple LoggerFactory::Call::CreateLoggerSimple(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLoggerSimple(std::move(_client_end), std::move(_request_buffer), std::move(profile), std::move(logger), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerFactory::CreateLoggerSimpleResponse> LoggerFactory::InPlace::CreateLoggerSimple(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateLoggerSimpleRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerFactory::CreateLoggerSimpleResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CreateLoggerSimpleRequest, CreateLoggerSimpleResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerFactory::CreateLoggerSimpleResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerFactory::ResultOf::CreateLoggerFromProjectId_Impl<LoggerFactory::CreateLoggerFromProjectIdResponse>::CreateLoggerFromProjectId_Impl(::zx::unowned_channel _client_end, uint32_t project_id, ::zx::channel logger) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLoggerFromProjectIdRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CreateLoggerFromProjectIdRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateLoggerFromProjectIdRequest*>(_write_bytes);
+ _request.project_id = std::move(project_id);
+ _request.logger = std::move(logger);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLoggerFromProjectIdRequest));
+ ::fidl::DecodedMessage<CreateLoggerFromProjectIdRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ LoggerFactory::InPlace::CreateLoggerFromProjectId(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerFactory::ResultOf::CreateLoggerFromProjectId LoggerFactory::SyncClient::CreateLoggerFromProjectId(uint32_t project_id, ::zx::channel logger) {
+ return ResultOf::CreateLoggerFromProjectId(::zx::unowned_channel(this->channel_), std::move(project_id), std::move(logger));
+}
+
+LoggerFactory::ResultOf::CreateLoggerFromProjectId LoggerFactory::Call::CreateLoggerFromProjectId(::zx::unowned_channel _client_end, uint32_t project_id, ::zx::channel logger) {
+ return ResultOf::CreateLoggerFromProjectId(std::move(_client_end), std::move(project_id), std::move(logger));
+}
+
+template <>
+LoggerFactory::UnownedResultOf::CreateLoggerFromProjectId_Impl<LoggerFactory::CreateLoggerFromProjectIdResponse>::CreateLoggerFromProjectId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CreateLoggerFromProjectIdRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CreateLoggerFromProjectIdResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CreateLoggerFromProjectIdRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateLoggerFromProjectIdRequest*>(_request_buffer.data());
+ _request.project_id = std::move(project_id);
+ _request.logger = std::move(logger);
+ _request_buffer.set_actual(sizeof(CreateLoggerFromProjectIdRequest));
+ ::fidl::DecodedMessage<CreateLoggerFromProjectIdRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ LoggerFactory::InPlace::CreateLoggerFromProjectId(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerFactory::UnownedResultOf::CreateLoggerFromProjectId LoggerFactory::SyncClient::CreateLoggerFromProjectId(::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLoggerFromProjectId(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(project_id), std::move(logger), std::move(_response_buffer));
+}
+
+LoggerFactory::UnownedResultOf::CreateLoggerFromProjectId LoggerFactory::Call::CreateLoggerFromProjectId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLoggerFromProjectId(std::move(_client_end), std::move(_request_buffer), std::move(project_id), std::move(logger), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerFactory::CreateLoggerFromProjectIdResponse> LoggerFactory::InPlace::CreateLoggerFromProjectId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateLoggerFromProjectIdRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerFromProjectIdRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerFactory::CreateLoggerFromProjectIdResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CreateLoggerFromProjectIdRequest, CreateLoggerFromProjectIdResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerFactory::CreateLoggerFromProjectIdResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+LoggerFactory::ResultOf::CreateLoggerSimpleFromProjectId_Impl<LoggerFactory::CreateLoggerSimpleFromProjectIdResponse>::CreateLoggerSimpleFromProjectId_Impl(::zx::unowned_channel _client_end, uint32_t project_id, ::zx::channel logger) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLoggerSimpleFromProjectIdRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CreateLoggerSimpleFromProjectIdRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateLoggerSimpleFromProjectIdRequest*>(_write_bytes);
+ _request.project_id = std::move(project_id);
+ _request.logger = std::move(logger);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLoggerSimpleFromProjectIdRequest));
+ ::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ LoggerFactory::InPlace::CreateLoggerSimpleFromProjectId(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+LoggerFactory::ResultOf::CreateLoggerSimpleFromProjectId LoggerFactory::SyncClient::CreateLoggerSimpleFromProjectId(uint32_t project_id, ::zx::channel logger) {
+ return ResultOf::CreateLoggerSimpleFromProjectId(::zx::unowned_channel(this->channel_), std::move(project_id), std::move(logger));
+}
+
+LoggerFactory::ResultOf::CreateLoggerSimpleFromProjectId LoggerFactory::Call::CreateLoggerSimpleFromProjectId(::zx::unowned_channel _client_end, uint32_t project_id, ::zx::channel logger) {
+ return ResultOf::CreateLoggerSimpleFromProjectId(std::move(_client_end), std::move(project_id), std::move(logger));
+}
+
+template <>
+LoggerFactory::UnownedResultOf::CreateLoggerSimpleFromProjectId_Impl<LoggerFactory::CreateLoggerSimpleFromProjectIdResponse>::CreateLoggerSimpleFromProjectId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CreateLoggerSimpleFromProjectIdRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CreateLoggerSimpleFromProjectIdResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CreateLoggerSimpleFromProjectIdRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateLoggerSimpleFromProjectIdRequest*>(_request_buffer.data());
+ _request.project_id = std::move(project_id);
+ _request.logger = std::move(logger);
+ _request_buffer.set_actual(sizeof(CreateLoggerSimpleFromProjectIdRequest));
+ ::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ LoggerFactory::InPlace::CreateLoggerSimpleFromProjectId(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+LoggerFactory::UnownedResultOf::CreateLoggerSimpleFromProjectId LoggerFactory::SyncClient::CreateLoggerSimpleFromProjectId(::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLoggerSimpleFromProjectId(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(project_id), std::move(logger), std::move(_response_buffer));
+}
+
+LoggerFactory::UnownedResultOf::CreateLoggerSimpleFromProjectId LoggerFactory::Call::CreateLoggerSimpleFromProjectId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLoggerSimpleFromProjectId(std::move(_client_end), std::move(_request_buffer), std::move(project_id), std::move(logger), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<LoggerFactory::CreateLoggerSimpleFromProjectIdResponse> LoggerFactory::InPlace::CreateLoggerSimpleFromProjectId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdRequest> params, ::fidl::BytePart response_buffer) {
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleFromProjectIdRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerFactory::CreateLoggerSimpleFromProjectIdResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CreateLoggerSimpleFromProjectIdRequest, CreateLoggerSimpleFromProjectIdResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<LoggerFactory::CreateLoggerSimpleFromProjectIdResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool LoggerFactory::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kLoggerFactory_CreateLogger_Ordinal:
+ case kLoggerFactory_CreateLogger_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateLoggerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateLogger(std::move(message->profile), std::move(message->logger),
+ Interface::CreateLoggerCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerFactory_CreateLoggerSimple_Ordinal:
+ case kLoggerFactory_CreateLoggerSimple_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateLoggerSimpleRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateLoggerSimple(std::move(message->profile), std::move(message->logger),
+ Interface::CreateLoggerSimpleCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerFactory_CreateLoggerFromProjectId_Ordinal:
+ case kLoggerFactory_CreateLoggerFromProjectId_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateLoggerFromProjectIdRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateLoggerFromProjectId(std::move(message->project_id), std::move(message->logger),
+ Interface::CreateLoggerFromProjectIdCompleter::Sync(txn));
+ return true;
+ }
+ case kLoggerFactory_CreateLoggerSimpleFromProjectId_Ordinal:
+ case kLoggerFactory_CreateLoggerSimpleFromProjectId_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateLoggerSimpleFromProjectIdRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateLoggerSimpleFromProjectId(std::move(message->project_id), std::move(message->logger),
+ Interface::CreateLoggerSimpleFromProjectIdCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool LoggerFactory::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void LoggerFactory::Interface::CreateLoggerCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLoggerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CreateLoggerResponse*>(_write_bytes);
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerResponse(
+ ::fidl::DecodedMessage<CreateLoggerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLoggerResponse::PrimarySize,
+ CreateLoggerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLoggerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLoggerResponse>(std::move(_response_bytes)));
+}
+
+void LoggerFactory::Interface::CreateLoggerCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < CreateLoggerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CreateLoggerResponse*>(_buffer.data());
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerResponse(
+ ::fidl::DecodedMessage<CreateLoggerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLoggerResponse::PrimarySize,
+ CreateLoggerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CreateLoggerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLoggerResponse>(std::move(_buffer)));
+}
+
+void LoggerFactory::Interface::CreateLoggerCompleterBase::Reply(::fidl::DecodedMessage<CreateLoggerResponse> params) {
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerFactory::Interface::CreateLoggerSimpleCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLoggerSimpleResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CreateLoggerSimpleResponse*>(_write_bytes);
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleResponse(
+ ::fidl::DecodedMessage<CreateLoggerSimpleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLoggerSimpleResponse::PrimarySize,
+ CreateLoggerSimpleResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLoggerSimpleResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLoggerSimpleResponse>(std::move(_response_bytes)));
+}
+
+void LoggerFactory::Interface::CreateLoggerSimpleCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < CreateLoggerSimpleResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CreateLoggerSimpleResponse*>(_buffer.data());
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleResponse(
+ ::fidl::DecodedMessage<CreateLoggerSimpleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLoggerSimpleResponse::PrimarySize,
+ CreateLoggerSimpleResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CreateLoggerSimpleResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLoggerSimpleResponse>(std::move(_buffer)));
+}
+
+void LoggerFactory::Interface::CreateLoggerSimpleCompleterBase::Reply(::fidl::DecodedMessage<CreateLoggerSimpleResponse> params) {
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerFactory::Interface::CreateLoggerFromProjectIdCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLoggerFromProjectIdResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CreateLoggerFromProjectIdResponse*>(_write_bytes);
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerFromProjectIdResponse(
+ ::fidl::DecodedMessage<CreateLoggerFromProjectIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLoggerFromProjectIdResponse::PrimarySize,
+ CreateLoggerFromProjectIdResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLoggerFromProjectIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLoggerFromProjectIdResponse>(std::move(_response_bytes)));
+}
+
+void LoggerFactory::Interface::CreateLoggerFromProjectIdCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < CreateLoggerFromProjectIdResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CreateLoggerFromProjectIdResponse*>(_buffer.data());
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerFromProjectIdResponse(
+ ::fidl::DecodedMessage<CreateLoggerFromProjectIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLoggerFromProjectIdResponse::PrimarySize,
+ CreateLoggerFromProjectIdResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CreateLoggerFromProjectIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLoggerFromProjectIdResponse>(std::move(_buffer)));
+}
+
+void LoggerFactory::Interface::CreateLoggerFromProjectIdCompleterBase::Reply(::fidl::DecodedMessage<CreateLoggerFromProjectIdResponse> params) {
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerFromProjectIdResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void LoggerFactory::Interface::CreateLoggerSimpleFromProjectIdCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLoggerSimpleFromProjectIdResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CreateLoggerSimpleFromProjectIdResponse*>(_write_bytes);
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleFromProjectIdResponse(
+ ::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLoggerSimpleFromProjectIdResponse::PrimarySize,
+ CreateLoggerSimpleFromProjectIdResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLoggerSimpleFromProjectIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdResponse>(std::move(_response_bytes)));
+}
+
+void LoggerFactory::Interface::CreateLoggerSimpleFromProjectIdCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < CreateLoggerSimpleFromProjectIdResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CreateLoggerSimpleFromProjectIdResponse*>(_buffer.data());
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleFromProjectIdResponse(
+ ::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLoggerSimpleFromProjectIdResponse::PrimarySize,
+ CreateLoggerSimpleFromProjectIdResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CreateLoggerSimpleFromProjectIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdResponse>(std::move(_buffer)));
+}
+
+void LoggerFactory::Interface::CreateLoggerSimpleFromProjectIdCompleterBase::Reply(::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdResponse> params) {
+ LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleFromProjectIdResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void LoggerFactory::SetTransactionHeaderFor::CreateLoggerRequest(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerFactory_CreateLogger_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerFactory::SetTransactionHeaderFor::CreateLoggerResponse(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerFactory_CreateLogger_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleRequest(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerSimpleRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerFactory_CreateLoggerSimple_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleResponse(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerSimpleResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerFactory_CreateLoggerSimple_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerFactory::SetTransactionHeaderFor::CreateLoggerFromProjectIdRequest(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerFromProjectIdRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerFactory_CreateLoggerFromProjectId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerFactory::SetTransactionHeaderFor::CreateLoggerFromProjectIdResponse(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerFromProjectIdResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerFactory_CreateLoggerFromProjectId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleFromProjectIdRequest(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerSimpleFromProjectIdRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerFactory_CreateLoggerSimpleFromProjectId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void LoggerFactory::SetTransactionHeaderFor::CreateLoggerSimpleFromProjectIdResponse(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerSimpleFromProjectIdResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoggerFactory_CreateLoggerSimpleFromProjectId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kSystemDataUpdater_SetExperimentState_Ordinal = 0x7179ca9100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSystemDataUpdater_SetExperimentState_GenOrdinal = 0x64c8f26bffbe2e2elu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_SystemDataUpdaterSetExperimentStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_SystemDataUpdaterSetExperimentStateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSystemDataUpdater_SetChannel_Ordinal = 0x37f1709100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSystemDataUpdater_SetChannel_GenOrdinal = 0x550a753f31ff2ce2lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_SystemDataUpdaterSetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_SystemDataUpdaterSetChannelResponseTable;
+
+} // namespace
+template <>
+SystemDataUpdater::ResultOf::SetExperimentState_Impl<SystemDataUpdater::SetExperimentStateResponse>::SetExperimentState_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetExperimentStateRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetExperimentStateRequest _request = {};
+ _request.experiments = std::move(experiments);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetExperimentStateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ SystemDataUpdater::InPlace::SetExperimentState(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+SystemDataUpdater::ResultOf::SetExperimentState SystemDataUpdater::SyncClient::SetExperimentState(::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments) {
+ return ResultOf::SetExperimentState(::zx::unowned_channel(this->channel_), std::move(experiments));
+}
+
+SystemDataUpdater::ResultOf::SetExperimentState SystemDataUpdater::Call::SetExperimentState(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments) {
+ return ResultOf::SetExperimentState(std::move(_client_end), std::move(experiments));
+}
+
+template <>
+SystemDataUpdater::UnownedResultOf::SetExperimentState_Impl<SystemDataUpdater::SetExperimentStateResponse>::SetExperimentState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetExperimentStateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetExperimentStateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetExperimentStateRequest _request = {};
+ _request.experiments = std::move(experiments);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetExperimentStateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ SystemDataUpdater::InPlace::SetExperimentState(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+SystemDataUpdater::UnownedResultOf::SetExperimentState SystemDataUpdater::SyncClient::SetExperimentState(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetExperimentState(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(experiments), std::move(_response_buffer));
+}
+
+SystemDataUpdater::UnownedResultOf::SetExperimentState SystemDataUpdater::Call::SetExperimentState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetExperimentState(std::move(_client_end), std::move(_request_buffer), std::move(experiments), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SystemDataUpdater::SetExperimentStateResponse> SystemDataUpdater::InPlace::SetExperimentState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetExperimentStateRequest> params, ::fidl::BytePart response_buffer) {
+ SystemDataUpdater::SetTransactionHeaderFor::SetExperimentStateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SystemDataUpdater::SetExperimentStateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetExperimentStateRequest, SetExperimentStateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SystemDataUpdater::SetExperimentStateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+SystemDataUpdater::ResultOf::SetChannel_Impl<SystemDataUpdater::SetChannelResponse>::SetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::StringView current_channel) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetChannelRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ SetChannelRequest _request = {};
+ _request.current_channel = std::move(current_channel);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetChannelRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ SystemDataUpdater::InPlace::SetChannel(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+SystemDataUpdater::ResultOf::SetChannel SystemDataUpdater::SyncClient::SetChannel(::fidl::StringView current_channel) {
+ return ResultOf::SetChannel(::zx::unowned_channel(this->channel_), std::move(current_channel));
+}
+
+SystemDataUpdater::ResultOf::SetChannel SystemDataUpdater::Call::SetChannel(::zx::unowned_channel _client_end, ::fidl::StringView current_channel) {
+ return ResultOf::SetChannel(std::move(_client_end), std::move(current_channel));
+}
+
+template <>
+SystemDataUpdater::UnownedResultOf::SetChannel_Impl<SystemDataUpdater::SetChannelResponse>::SetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView current_channel, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetChannelRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetChannelResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetChannelRequest _request = {};
+ _request.current_channel = std::move(current_channel);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetChannelRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ SystemDataUpdater::InPlace::SetChannel(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+SystemDataUpdater::UnownedResultOf::SetChannel SystemDataUpdater::SyncClient::SetChannel(::fidl::BytePart _request_buffer, ::fidl::StringView current_channel, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetChannel(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(current_channel), std::move(_response_buffer));
+}
+
+SystemDataUpdater::UnownedResultOf::SetChannel SystemDataUpdater::Call::SetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView current_channel, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetChannel(std::move(_client_end), std::move(_request_buffer), std::move(current_channel), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SystemDataUpdater::SetChannelResponse> SystemDataUpdater::InPlace::SetChannel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetChannelRequest> params, ::fidl::BytePart response_buffer) {
+ SystemDataUpdater::SetTransactionHeaderFor::SetChannelRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SystemDataUpdater::SetChannelResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetChannelRequest, SetChannelResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SystemDataUpdater::SetChannelResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool SystemDataUpdater::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kSystemDataUpdater_SetExperimentState_Ordinal:
+ case kSystemDataUpdater_SetExperimentState_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetExperimentStateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetExperimentState(std::move(message->experiments),
+ Interface::SetExperimentStateCompleter::Sync(txn));
+ return true;
+ }
+ case kSystemDataUpdater_SetChannel_Ordinal:
+ case kSystemDataUpdater_SetChannel_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetChannelRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetChannel(std::move(message->current_channel),
+ Interface::SetChannelCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool SystemDataUpdater::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void SystemDataUpdater::Interface::SetExperimentStateCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetExperimentStateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetExperimentStateResponse*>(_write_bytes);
+ SystemDataUpdater::SetTransactionHeaderFor::SetExperimentStateResponse(
+ ::fidl::DecodedMessage<SetExperimentStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetExperimentStateResponse::PrimarySize,
+ SetExperimentStateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetExperimentStateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetExperimentStateResponse>(std::move(_response_bytes)));
+}
+
+void SystemDataUpdater::Interface::SetExperimentStateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < SetExperimentStateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetExperimentStateResponse*>(_buffer.data());
+ SystemDataUpdater::SetTransactionHeaderFor::SetExperimentStateResponse(
+ ::fidl::DecodedMessage<SetExperimentStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetExperimentStateResponse::PrimarySize,
+ SetExperimentStateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetExperimentStateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetExperimentStateResponse>(std::move(_buffer)));
+}
+
+void SystemDataUpdater::Interface::SetExperimentStateCompleterBase::Reply(::fidl::DecodedMessage<SetExperimentStateResponse> params) {
+ SystemDataUpdater::SetTransactionHeaderFor::SetExperimentStateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void SystemDataUpdater::Interface::SetChannelCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetChannelResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetChannelResponse*>(_write_bytes);
+ SystemDataUpdater::SetTransactionHeaderFor::SetChannelResponse(
+ ::fidl::DecodedMessage<SetChannelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetChannelResponse::PrimarySize,
+ SetChannelResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetChannelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetChannelResponse>(std::move(_response_bytes)));
+}
+
+void SystemDataUpdater::Interface::SetChannelCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < SetChannelResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetChannelResponse*>(_buffer.data());
+ SystemDataUpdater::SetTransactionHeaderFor::SetChannelResponse(
+ ::fidl::DecodedMessage<SetChannelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetChannelResponse::PrimarySize,
+ SetChannelResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetChannelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetChannelResponse>(std::move(_buffer)));
+}
+
+void SystemDataUpdater::Interface::SetChannelCompleterBase::Reply(::fidl::DecodedMessage<SetChannelResponse> params) {
+ SystemDataUpdater::SetTransactionHeaderFor::SetChannelResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void SystemDataUpdater::SetTransactionHeaderFor::SetExperimentStateRequest(const ::fidl::DecodedMessage<SystemDataUpdater::SetExperimentStateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSystemDataUpdater_SetExperimentState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SystemDataUpdater::SetTransactionHeaderFor::SetExperimentStateResponse(const ::fidl::DecodedMessage<SystemDataUpdater::SetExperimentStateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSystemDataUpdater_SetExperimentState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void SystemDataUpdater::SetTransactionHeaderFor::SetChannelRequest(const ::fidl::DecodedMessage<SystemDataUpdater::SetChannelRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSystemDataUpdater_SetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SystemDataUpdater::SetTransactionHeaderFor::SetChannelResponse(const ::fidl::DecodedMessage<SystemDataUpdater::SetChannelResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSystemDataUpdater_SetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::cobalt::EventPayload::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(EventPayload) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(EventPayload, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(EventPayload, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogEvent_Ordinal = 0x135d628d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogEvent_GenOrdinal = 0x293433df480dd41elu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogEventCount_Ordinal = 0x6fce776500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogEventCount_GenOrdinal = 0x5f73f8b900d4bbb1lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogEventCountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogEventCountResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogElapsedTime_Ordinal = 0x14f4912000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogElapsedTime_GenOrdinal = 0x42e58931fd6c785lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogElapsedTimeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogElapsedTimeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogFrameRate_Ordinal = 0x2b8722b800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogFrameRate_GenOrdinal = 0x4c701bca4836097lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogFrameRateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogFrameRateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogMemoryUsage_Ordinal = 0x66c69d1b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogMemoryUsage_GenOrdinal = 0x14189c11cc19d641lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogMemoryUsageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogMemoryUsageResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_StartTimer_Ordinal = 0x4a5c612000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_StartTimer_GenOrdinal = 0x68cec08d094e4938lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerStartTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerStartTimerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_EndTimer_Ordinal = 0x65db6e4200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_EndTimer_GenOrdinal = 0xf0043bc7ed4b561lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerEndTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerEndTimerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogIntHistogram_Ordinal = 0x7afcfd3000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogIntHistogram_GenOrdinal = 0x3382c4827c0c0b0elu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogIntHistogramRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogIntHistogramResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogCustomEvent_Ordinal = 0x3cfd7fbc00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogCustomEvent_GenOrdinal = 0x65d92921e13e94b8lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCustomEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCustomEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogCobaltEvent_Ordinal = 0x667d288400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogCobaltEvent_GenOrdinal = 0x2da5db50fd49332lu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCobaltEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCobaltEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogCobaltEvents_Ordinal = 0x2905d69400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLogger_LogCobaltEvents_GenOrdinal = 0x4e51a78396369f7flu;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCobaltEventsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCobaltEventsResponseTable;
+
+} // namespace
+template <>
+Logger::ResultOf::LogEvent_Impl<Logger::LogEventResponse>::LogEvent_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, LogEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<LogEventRequest*>(_write_bytes);
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventRequest));
+ ::fidl::DecodedMessage<LogEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Logger::InPlace::LogEvent(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogEvent Logger::SyncClient::LogEvent(uint32_t metric_id, uint32_t event_code) {
+ return ResultOf::LogEvent(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code));
+}
+
+Logger::ResultOf::LogEvent Logger::Call::LogEvent(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code) {
+ return ResultOf::LogEvent(std::move(_client_end), std::move(metric_id), std::move(event_code));
+}
+
+template <>
+Logger::UnownedResultOf::LogEvent_Impl<Logger::LogEventResponse>::LogEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogEventRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogEventResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, LogEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<LogEventRequest*>(_request_buffer.data());
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request_buffer.set_actual(sizeof(LogEventRequest));
+ ::fidl::DecodedMessage<LogEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Logger::InPlace::LogEvent(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogEvent Logger::SyncClient::LogEvent(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEvent(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogEvent Logger::Call::LogEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEvent(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogEventResponse> Logger::InPlace::LogEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogEventRequest, LogEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::LogEventCount_Impl<Logger::LogEventCountResponse>::LogEventCount_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventCountRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogEventCountRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.period_duration_micros = std::move(period_duration_micros);
+ _request.count = std::move(count);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogEventCountRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogEventCount(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogEventCount Logger::SyncClient::LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ return ResultOf::LogEventCount(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count));
+}
+
+Logger::ResultOf::LogEventCount Logger::Call::LogEventCount(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count) {
+ return ResultOf::LogEventCount(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count));
+}
+
+template <>
+Logger::UnownedResultOf::LogEventCount_Impl<Logger::LogEventCountResponse>::LogEventCount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogEventCountRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogEventCountResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogEventCountRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.period_duration_micros = std::move(period_duration_micros);
+ _request.count = std::move(count);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogEventCountRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogEventCount(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogEventCount Logger::SyncClient::LogEventCount(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEventCount(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogEventCount Logger::Call::LogEventCount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogEventCount(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(period_duration_micros), std::move(count), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogEventCountResponse> Logger::InPlace::LogEventCount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventCountRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogEventCountRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogEventCountResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogEventCountRequest, LogEventCountResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogEventCountResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::LogElapsedTime_Impl<Logger::LogElapsedTimeResponse>::LogElapsedTime_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogElapsedTimeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogElapsedTimeRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.elapsed_micros = std::move(elapsed_micros);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogElapsedTimeRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogElapsedTime(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogElapsedTime Logger::SyncClient::LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ return ResultOf::LogElapsedTime(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros));
+}
+
+Logger::ResultOf::LogElapsedTime Logger::Call::LogElapsedTime(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros) {
+ return ResultOf::LogElapsedTime(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros));
+}
+
+template <>
+Logger::UnownedResultOf::LogElapsedTime_Impl<Logger::LogElapsedTimeResponse>::LogElapsedTime_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogElapsedTimeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogElapsedTimeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogElapsedTimeRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.elapsed_micros = std::move(elapsed_micros);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogElapsedTimeRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogElapsedTime(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogElapsedTime Logger::SyncClient::LogElapsedTime(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogElapsedTime(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogElapsedTime Logger::Call::LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogElapsedTime(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(elapsed_micros), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogElapsedTimeResponse> Logger::InPlace::LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogElapsedTimeRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogElapsedTimeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogElapsedTimeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogElapsedTimeRequest, LogElapsedTimeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogElapsedTimeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::LogFrameRate_Impl<Logger::LogFrameRateResponse>::LogFrameRate_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogFrameRateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogFrameRateRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.fps = std::move(fps);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogFrameRateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogFrameRate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogFrameRate Logger::SyncClient::LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ return ResultOf::LogFrameRate(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps));
+}
+
+Logger::ResultOf::LogFrameRate Logger::Call::LogFrameRate(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps) {
+ return ResultOf::LogFrameRate(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps));
+}
+
+template <>
+Logger::UnownedResultOf::LogFrameRate_Impl<Logger::LogFrameRateResponse>::LogFrameRate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogFrameRateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogFrameRateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogFrameRateRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.fps = std::move(fps);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogFrameRateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogFrameRate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogFrameRate Logger::SyncClient::LogFrameRate(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogFrameRate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogFrameRate Logger::Call::LogFrameRate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogFrameRate(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(fps), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogFrameRateResponse> Logger::InPlace::LogFrameRate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogFrameRateRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogFrameRateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogFrameRateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogFrameRateRequest, LogFrameRateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogFrameRateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::LogMemoryUsage_Impl<Logger::LogMemoryUsageResponse>::LogMemoryUsage_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogMemoryUsageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LogMemoryUsageRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.bytes = std::move(bytes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogMemoryUsageRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogMemoryUsage(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogMemoryUsage Logger::SyncClient::LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ return ResultOf::LogMemoryUsage(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes));
+}
+
+Logger::ResultOf::LogMemoryUsage Logger::Call::LogMemoryUsage(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes) {
+ return ResultOf::LogMemoryUsage(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes));
+}
+
+template <>
+Logger::UnownedResultOf::LogMemoryUsage_Impl<Logger::LogMemoryUsageResponse>::LogMemoryUsage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogMemoryUsageRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogMemoryUsageResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogMemoryUsageRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.bytes = std::move(bytes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogMemoryUsageRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogMemoryUsage(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogMemoryUsage Logger::SyncClient::LogMemoryUsage(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogMemoryUsage(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogMemoryUsage Logger::Call::LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogMemoryUsage(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(bytes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogMemoryUsageResponse> Logger::InPlace::LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogMemoryUsageRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogMemoryUsageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogMemoryUsageResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogMemoryUsageRequest, LogMemoryUsageResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogMemoryUsageResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::StartTimer_Impl<Logger::StartTimerResponse>::StartTimer_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartTimerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ StartTimerRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<StartTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::StartTimer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::StartTimer Logger::SyncClient::StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::StartTimer(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+Logger::ResultOf::StartTimer Logger::Call::StartTimer(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::StartTimer(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+template <>
+Logger::UnownedResultOf::StartTimer_Impl<Logger::StartTimerResponse>::StartTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < StartTimerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<StartTimerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ StartTimerRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<StartTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::StartTimer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::StartTimer Logger::SyncClient::StartTimer(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StartTimer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::StartTimer Logger::Call::StartTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StartTimer(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::StartTimerResponse> Logger::InPlace::StartTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StartTimerRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::StartTimerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::StartTimerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StartTimerRequest, StartTimerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::StartTimerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::EndTimer_Impl<Logger::EndTimerResponse>::EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EndTimerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ EndTimerRequest _request = {};
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EndTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::EndTimer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::EndTimer Logger::SyncClient::EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::EndTimer(::zx::unowned_channel(this->channel_), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+Logger::ResultOf::EndTimer Logger::Call::EndTimer(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s) {
+ return ResultOf::EndTimer(std::move(_client_end), std::move(timer_id), std::move(timestamp), std::move(timeout_s));
+}
+
+template <>
+Logger::UnownedResultOf::EndTimer_Impl<Logger::EndTimerResponse>::EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < EndTimerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<EndTimerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ EndTimerRequest _request = {};
+ _request.timer_id = std::move(timer_id);
+ _request.timestamp = std::move(timestamp);
+ _request.timeout_s = std::move(timeout_s);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EndTimerRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::EndTimer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::EndTimer Logger::SyncClient::EndTimer(::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EndTimer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::EndTimer Logger::Call::EndTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EndTimer(std::move(_client_end), std::move(_request_buffer), std::move(timer_id), std::move(timestamp), std::move(timeout_s), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::EndTimerResponse> Logger::InPlace::EndTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EndTimerRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::EndTimerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::EndTimerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<EndTimerRequest, EndTimerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::EndTimerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::LogIntHistogram_Impl<Logger::LogIntHistogramResponse>::LogIntHistogram_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogIntHistogramRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LogIntHistogramRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.histogram = std::move(histogram);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogIntHistogramRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogIntHistogram(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogIntHistogram Logger::SyncClient::LogIntHistogram(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram) {
+ return ResultOf::LogIntHistogram(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_code), std::move(component), std::move(histogram));
+}
+
+Logger::ResultOf::LogIntHistogram Logger::Call::LogIntHistogram(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram) {
+ return ResultOf::LogIntHistogram(std::move(_client_end), std::move(metric_id), std::move(event_code), std::move(component), std::move(histogram));
+}
+
+template <>
+Logger::UnownedResultOf::LogIntHistogram_Impl<Logger::LogIntHistogramResponse>::LogIntHistogram_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogIntHistogramRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogIntHistogramResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogIntHistogramRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_code = std::move(event_code);
+ _request.component = std::move(component);
+ _request.histogram = std::move(histogram);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogIntHistogramRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogIntHistogram(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogIntHistogram Logger::SyncClient::LogIntHistogram(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogIntHistogram(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(histogram), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogIntHistogram Logger::Call::LogIntHistogram(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogIntHistogram(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_code), std::move(component), std::move(histogram), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogIntHistogramResponse> Logger::InPlace::LogIntHistogram(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogIntHistogramRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogIntHistogramRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogIntHistogramResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogIntHistogramRequest, LogIntHistogramResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogIntHistogramResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::LogCustomEvent_Impl<Logger::LogCustomEventResponse>::LogCustomEvent_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogCustomEventRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LogCustomEventRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_values = std::move(event_values);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogCustomEventRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogCustomEvent(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogCustomEvent Logger::SyncClient::LogCustomEvent(uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values) {
+ return ResultOf::LogCustomEvent(::zx::unowned_channel(this->channel_), std::move(metric_id), std::move(event_values));
+}
+
+Logger::ResultOf::LogCustomEvent Logger::Call::LogCustomEvent(::zx::unowned_channel _client_end, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values) {
+ return ResultOf::LogCustomEvent(std::move(_client_end), std::move(metric_id), std::move(event_values));
+}
+
+template <>
+Logger::UnownedResultOf::LogCustomEvent_Impl<Logger::LogCustomEventResponse>::LogCustomEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogCustomEventRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogCustomEventResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogCustomEventRequest _request = {};
+ _request.metric_id = std::move(metric_id);
+ _request.event_values = std::move(event_values);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogCustomEventRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogCustomEvent(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogCustomEvent Logger::SyncClient::LogCustomEvent(::fidl::BytePart _request_buffer, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogCustomEvent(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(metric_id), std::move(event_values), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogCustomEvent Logger::Call::LogCustomEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogCustomEvent(std::move(_client_end), std::move(_request_buffer), std::move(metric_id), std::move(event_values), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogCustomEventResponse> Logger::InPlace::LogCustomEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogCustomEventRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogCustomEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogCustomEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogCustomEventRequest, LogCustomEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogCustomEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::LogCobaltEvent_Impl<Logger::LogCobaltEventResponse>::LogCobaltEvent_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::CobaltEvent event) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogCobaltEventRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LogCobaltEventRequest _request = {};
+ _request.event = std::move(event);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogCobaltEventRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogCobaltEvent(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogCobaltEvent Logger::SyncClient::LogCobaltEvent(::llcpp::fuchsia::cobalt::CobaltEvent event) {
+ return ResultOf::LogCobaltEvent(::zx::unowned_channel(this->channel_), std::move(event));
+}
+
+Logger::ResultOf::LogCobaltEvent Logger::Call::LogCobaltEvent(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::CobaltEvent event) {
+ return ResultOf::LogCobaltEvent(std::move(_client_end), std::move(event));
+}
+
+template <>
+Logger::UnownedResultOf::LogCobaltEvent_Impl<Logger::LogCobaltEventResponse>::LogCobaltEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::CobaltEvent event, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogCobaltEventRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogCobaltEventResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogCobaltEventRequest _request = {};
+ _request.event = std::move(event);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogCobaltEventRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogCobaltEvent(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogCobaltEvent Logger::SyncClient::LogCobaltEvent(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::CobaltEvent event, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogCobaltEvent(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(event), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogCobaltEvent Logger::Call::LogCobaltEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::CobaltEvent event, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogCobaltEvent(std::move(_client_end), std::move(_request_buffer), std::move(event), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogCobaltEventResponse> Logger::InPlace::LogCobaltEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogCobaltEventRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogCobaltEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogCobaltEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogCobaltEventRequest, LogCobaltEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogCobaltEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Logger::ResultOf::LogCobaltEvents_Impl<Logger::LogCobaltEventsResponse>::LogCobaltEvents_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogCobaltEventsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LogCobaltEventsRequest _request = {};
+ _request.events = std::move(events);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogCobaltEventsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogCobaltEvents(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Logger::ResultOf::LogCobaltEvents Logger::SyncClient::LogCobaltEvents(::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events) {
+ return ResultOf::LogCobaltEvents(::zx::unowned_channel(this->channel_), std::move(events));
+}
+
+Logger::ResultOf::LogCobaltEvents Logger::Call::LogCobaltEvents(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events) {
+ return ResultOf::LogCobaltEvents(std::move(_client_end), std::move(events));
+}
+
+template <>
+Logger::UnownedResultOf::LogCobaltEvents_Impl<Logger::LogCobaltEventsResponse>::LogCobaltEvents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LogCobaltEventsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LogCobaltEventsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LogCobaltEventsRequest _request = {};
+ _request.events = std::move(events);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LogCobaltEventsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Logger::InPlace::LogCobaltEvents(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Logger::UnownedResultOf::LogCobaltEvents Logger::SyncClient::LogCobaltEvents(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogCobaltEvents(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(events), std::move(_response_buffer));
+}
+
+Logger::UnownedResultOf::LogCobaltEvents Logger::Call::LogCobaltEvents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LogCobaltEvents(std::move(_client_end), std::move(_request_buffer), std::move(events), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Logger::LogCobaltEventsResponse> Logger::InPlace::LogCobaltEvents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogCobaltEventsRequest> params, ::fidl::BytePart response_buffer) {
+ Logger::SetTransactionHeaderFor::LogCobaltEventsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogCobaltEventsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LogCobaltEventsRequest, LogCobaltEventsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Logger::LogCobaltEventsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Logger::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kLogger_LogEvent_Ordinal:
+ case kLogger_LogEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogEvent(std::move(message->metric_id), std::move(message->event_code),
+ Interface::LogEventCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_LogEventCount_Ordinal:
+ case kLogger_LogEventCount_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogEventCountRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogEventCount(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->period_duration_micros), std::move(message->count),
+ Interface::LogEventCountCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_LogElapsedTime_Ordinal:
+ case kLogger_LogElapsedTime_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogElapsedTimeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogElapsedTime(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->elapsed_micros),
+ Interface::LogElapsedTimeCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_LogFrameRate_Ordinal:
+ case kLogger_LogFrameRate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogFrameRateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogFrameRate(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->fps),
+ Interface::LogFrameRateCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_LogMemoryUsage_Ordinal:
+ case kLogger_LogMemoryUsage_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogMemoryUsageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogMemoryUsage(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->bytes),
+ Interface::LogMemoryUsageCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_StartTimer_Ordinal:
+ case kLogger_StartTimer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StartTimerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->StartTimer(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->timer_id), std::move(message->timestamp), std::move(message->timeout_s),
+ Interface::StartTimerCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_EndTimer_Ordinal:
+ case kLogger_EndTimer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EndTimerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->EndTimer(std::move(message->timer_id), std::move(message->timestamp), std::move(message->timeout_s),
+ Interface::EndTimerCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_LogIntHistogram_Ordinal:
+ case kLogger_LogIntHistogram_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogIntHistogramRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogIntHistogram(std::move(message->metric_id), std::move(message->event_code), std::move(message->component), std::move(message->histogram),
+ Interface::LogIntHistogramCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_LogCustomEvent_Ordinal:
+ case kLogger_LogCustomEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogCustomEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogCustomEvent(std::move(message->metric_id), std::move(message->event_values),
+ Interface::LogCustomEventCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_LogCobaltEvent_Ordinal:
+ case kLogger_LogCobaltEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogCobaltEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogCobaltEvent(std::move(message->event),
+ Interface::LogCobaltEventCompleter::Sync(txn));
+ return true;
+ }
+ case kLogger_LogCobaltEvents_Ordinal:
+ case kLogger_LogCobaltEvents_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LogCobaltEventsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LogCobaltEvents(std::move(message->events),
+ Interface::LogCobaltEventsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Logger::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Logger::Interface::LogEventCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogEventResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogEventResponse(
+ ::fidl::DecodedMessage<LogEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventResponse::PrimarySize,
+ LogEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogEventCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogEventResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogEventResponse(
+ ::fidl::DecodedMessage<LogEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventResponse::PrimarySize,
+ LogEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogEventCompleterBase::Reply(::fidl::DecodedMessage<LogEventResponse> params) {
+ Logger::SetTransactionHeaderFor::LogEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::LogEventCountCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogEventCountResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogEventCountResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogEventCountResponse(
+ ::fidl::DecodedMessage<LogEventCountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventCountResponse::PrimarySize,
+ LogEventCountResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogEventCountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventCountResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogEventCountCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogEventCountResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogEventCountResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogEventCountResponse(
+ ::fidl::DecodedMessage<LogEventCountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogEventCountResponse::PrimarySize,
+ LogEventCountResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogEventCountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogEventCountResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogEventCountCompleterBase::Reply(::fidl::DecodedMessage<LogEventCountResponse> params) {
+ Logger::SetTransactionHeaderFor::LogEventCountResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::LogElapsedTimeCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogElapsedTimeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogElapsedTimeResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogElapsedTimeResponse(
+ ::fidl::DecodedMessage<LogElapsedTimeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogElapsedTimeResponse::PrimarySize,
+ LogElapsedTimeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogElapsedTimeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogElapsedTimeResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogElapsedTimeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogElapsedTimeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogElapsedTimeResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogElapsedTimeResponse(
+ ::fidl::DecodedMessage<LogElapsedTimeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogElapsedTimeResponse::PrimarySize,
+ LogElapsedTimeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogElapsedTimeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogElapsedTimeResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogElapsedTimeCompleterBase::Reply(::fidl::DecodedMessage<LogElapsedTimeResponse> params) {
+ Logger::SetTransactionHeaderFor::LogElapsedTimeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::LogFrameRateCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogFrameRateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogFrameRateResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogFrameRateResponse(
+ ::fidl::DecodedMessage<LogFrameRateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogFrameRateResponse::PrimarySize,
+ LogFrameRateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogFrameRateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogFrameRateResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogFrameRateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogFrameRateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogFrameRateResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogFrameRateResponse(
+ ::fidl::DecodedMessage<LogFrameRateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogFrameRateResponse::PrimarySize,
+ LogFrameRateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogFrameRateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogFrameRateResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogFrameRateCompleterBase::Reply(::fidl::DecodedMessage<LogFrameRateResponse> params) {
+ Logger::SetTransactionHeaderFor::LogFrameRateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::LogMemoryUsageCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogMemoryUsageResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogMemoryUsageResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogMemoryUsageResponse(
+ ::fidl::DecodedMessage<LogMemoryUsageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogMemoryUsageResponse::PrimarySize,
+ LogMemoryUsageResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogMemoryUsageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogMemoryUsageResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogMemoryUsageCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogMemoryUsageResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogMemoryUsageResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogMemoryUsageResponse(
+ ::fidl::DecodedMessage<LogMemoryUsageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogMemoryUsageResponse::PrimarySize,
+ LogMemoryUsageResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogMemoryUsageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogMemoryUsageResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogMemoryUsageCompleterBase::Reply(::fidl::DecodedMessage<LogMemoryUsageResponse> params) {
+ Logger::SetTransactionHeaderFor::LogMemoryUsageResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::StartTimerCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartTimerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StartTimerResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::StartTimerResponse(
+ ::fidl::DecodedMessage<StartTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartTimerResponse::PrimarySize,
+ StartTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartTimerResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::StartTimerCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < StartTimerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<StartTimerResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::StartTimerResponse(
+ ::fidl::DecodedMessage<StartTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartTimerResponse::PrimarySize,
+ StartTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(StartTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartTimerResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::StartTimerCompleterBase::Reply(::fidl::DecodedMessage<StartTimerResponse> params) {
+ Logger::SetTransactionHeaderFor::StartTimerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::EndTimerCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EndTimerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<EndTimerResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::EndTimerResponse(
+ ::fidl::DecodedMessage<EndTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EndTimerResponse::PrimarySize,
+ EndTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(EndTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EndTimerResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::EndTimerCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < EndTimerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<EndTimerResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::EndTimerResponse(
+ ::fidl::DecodedMessage<EndTimerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EndTimerResponse::PrimarySize,
+ EndTimerResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(EndTimerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EndTimerResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::EndTimerCompleterBase::Reply(::fidl::DecodedMessage<EndTimerResponse> params) {
+ Logger::SetTransactionHeaderFor::EndTimerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::LogIntHistogramCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogIntHistogramResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogIntHistogramResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogIntHistogramResponse(
+ ::fidl::DecodedMessage<LogIntHistogramResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogIntHistogramResponse::PrimarySize,
+ LogIntHistogramResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogIntHistogramResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogIntHistogramResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogIntHistogramCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogIntHistogramResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogIntHistogramResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogIntHistogramResponse(
+ ::fidl::DecodedMessage<LogIntHistogramResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogIntHistogramResponse::PrimarySize,
+ LogIntHistogramResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogIntHistogramResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogIntHistogramResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogIntHistogramCompleterBase::Reply(::fidl::DecodedMessage<LogIntHistogramResponse> params) {
+ Logger::SetTransactionHeaderFor::LogIntHistogramResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::LogCustomEventCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogCustomEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogCustomEventResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogCustomEventResponse(
+ ::fidl::DecodedMessage<LogCustomEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogCustomEventResponse::PrimarySize,
+ LogCustomEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogCustomEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogCustomEventResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogCustomEventCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogCustomEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogCustomEventResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogCustomEventResponse(
+ ::fidl::DecodedMessage<LogCustomEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogCustomEventResponse::PrimarySize,
+ LogCustomEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogCustomEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogCustomEventResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogCustomEventCompleterBase::Reply(::fidl::DecodedMessage<LogCustomEventResponse> params) {
+ Logger::SetTransactionHeaderFor::LogCustomEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::LogCobaltEventCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogCobaltEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogCobaltEventResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogCobaltEventResponse(
+ ::fidl::DecodedMessage<LogCobaltEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogCobaltEventResponse::PrimarySize,
+ LogCobaltEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogCobaltEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogCobaltEventResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogCobaltEventCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogCobaltEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogCobaltEventResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogCobaltEventResponse(
+ ::fidl::DecodedMessage<LogCobaltEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogCobaltEventResponse::PrimarySize,
+ LogCobaltEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogCobaltEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogCobaltEventResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogCobaltEventCompleterBase::Reply(::fidl::DecodedMessage<LogCobaltEventResponse> params) {
+ Logger::SetTransactionHeaderFor::LogCobaltEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Logger::Interface::LogCobaltEventsCompleterBase::Reply(::llcpp::fuchsia::cobalt::Status status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LogCobaltEventsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LogCobaltEventsResponse*>(_write_bytes);
+ Logger::SetTransactionHeaderFor::LogCobaltEventsResponse(
+ ::fidl::DecodedMessage<LogCobaltEventsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogCobaltEventsResponse::PrimarySize,
+ LogCobaltEventsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LogCobaltEventsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogCobaltEventsResponse>(std::move(_response_bytes)));
+}
+
+void Logger::Interface::LogCobaltEventsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status) {
+ if (_buffer.capacity() < LogCobaltEventsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LogCobaltEventsResponse*>(_buffer.data());
+ Logger::SetTransactionHeaderFor::LogCobaltEventsResponse(
+ ::fidl::DecodedMessage<LogCobaltEventsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LogCobaltEventsResponse::PrimarySize,
+ LogCobaltEventsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(LogCobaltEventsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LogCobaltEventsResponse>(std::move(_buffer)));
+}
+
+void Logger::Interface::LogCobaltEventsCompleterBase::Reply(::fidl::DecodedMessage<LogCobaltEventsResponse> params) {
+ Logger::SetTransactionHeaderFor::LogCobaltEventsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Logger::SetTransactionHeaderFor::LogEventRequest(const ::fidl::DecodedMessage<Logger::LogEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogEventResponse(const ::fidl::DecodedMessage<Logger::LogEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::LogEventCountRequest(const ::fidl::DecodedMessage<Logger::LogEventCountRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogEventCount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogEventCountResponse(const ::fidl::DecodedMessage<Logger::LogEventCountResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogEventCount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::LogElapsedTimeRequest(const ::fidl::DecodedMessage<Logger::LogElapsedTimeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogElapsedTime_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogElapsedTimeResponse(const ::fidl::DecodedMessage<Logger::LogElapsedTimeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogElapsedTime_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::LogFrameRateRequest(const ::fidl::DecodedMessage<Logger::LogFrameRateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogFrameRate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogFrameRateResponse(const ::fidl::DecodedMessage<Logger::LogFrameRateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogFrameRate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::LogMemoryUsageRequest(const ::fidl::DecodedMessage<Logger::LogMemoryUsageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogMemoryUsage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogMemoryUsageResponse(const ::fidl::DecodedMessage<Logger::LogMemoryUsageResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogMemoryUsage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::StartTimerRequest(const ::fidl::DecodedMessage<Logger::StartTimerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_StartTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::StartTimerResponse(const ::fidl::DecodedMessage<Logger::StartTimerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_StartTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::EndTimerRequest(const ::fidl::DecodedMessage<Logger::EndTimerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_EndTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::EndTimerResponse(const ::fidl::DecodedMessage<Logger::EndTimerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_EndTimer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::LogIntHistogramRequest(const ::fidl::DecodedMessage<Logger::LogIntHistogramRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogIntHistogram_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogIntHistogramResponse(const ::fidl::DecodedMessage<Logger::LogIntHistogramResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogIntHistogram_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::LogCustomEventRequest(const ::fidl::DecodedMessage<Logger::LogCustomEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogCustomEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogCustomEventResponse(const ::fidl::DecodedMessage<Logger::LogCustomEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogCustomEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::LogCobaltEventRequest(const ::fidl::DecodedMessage<Logger::LogCobaltEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogCobaltEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogCobaltEventResponse(const ::fidl::DecodedMessage<Logger::LogCobaltEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogCobaltEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Logger::SetTransactionHeaderFor::LogCobaltEventsRequest(const ::fidl::DecodedMessage<Logger::LogCobaltEventsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogCobaltEvents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Logger::SetTransactionHeaderFor::LogCobaltEventsResponse(const ::fidl::DecodedMessage<Logger::LogCobaltEventsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLogger_LogCobaltEvents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace cobalt
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-cobalt/gen/llcpp/include/fuchsia/cobalt/llcpp/fidl.h b/zircon/system/fidl/fuchsia-cobalt/gen/llcpp/include/fuchsia/cobalt/llcpp/fidl.h
new file mode 100644
index 0000000..4f3fbc4
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-cobalt/gen/llcpp/include/fuchsia/cobalt/llcpp/fidl.h
@@ -0,0 +1,5533 @@
+// 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 <zircon/fidl.h>
+
+#include <fuchsia/mem/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace cobalt {
+
+struct Value;
+struct CustomEventValue;
+enum class Status : int32_t {
+ OK = 0u,
+ INVALID_ARGUMENTS = 1u,
+ EVENT_TOO_BIG = 2u,
+ BUFFER_FULL = 3u,
+ INTERNAL_ERROR = -1,
+};
+
+
+class Controller;
+class LoggerBase;
+class LoggerSimple;
+enum class ReleaseStage : int32_t {
+ GA = 0u,
+ DOGFOOD = 10u,
+ FISHFOOD = 20u,
+ DEBUG = 99u,
+};
+
+
+struct ProjectProfile;
+class LoggerFactory;
+struct HistogramBucket;
+struct Experiment;
+class SystemDataUpdater;
+struct Event;
+struct CountEvent;
+struct EventPayload;
+struct CobaltEvent;
+class Logger;
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ValueTable;
+
+struct Value {
+ Value() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kStringValue = 1, // 0x1
+ kIntValue = 2, // 0x2
+ kDoubleValue = 3, // 0x3
+ kIndexValue = 4, // 0x4
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_string_value() const { return ordinal() == Ordinal::kStringValue; }
+
+ static Value WithStringValue(::fidl::StringView* val) {
+ Value result;
+ result.set_string_value(val);
+ return result;
+ }
+
+ void set_string_value(::fidl::StringView* elem) {
+ ordinal_ = Ordinal::kStringValue;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::fidl::StringView& mutable_string_value() {
+ ZX_ASSERT(ordinal() == Ordinal::kStringValue);
+ return *static_cast<::fidl::StringView*>(envelope_.data);
+ }
+ const ::fidl::StringView& string_value() const {
+ ZX_ASSERT(ordinal() == Ordinal::kStringValue);
+ return *static_cast<::fidl::StringView*>(envelope_.data);
+ }
+
+ bool is_int_value() const { return ordinal() == Ordinal::kIntValue; }
+
+ static Value WithIntValue(int64_t* val) {
+ Value result;
+ result.set_int_value(val);
+ return result;
+ }
+
+ void set_int_value(int64_t* elem) {
+ ordinal_ = Ordinal::kIntValue;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int64_t& mutable_int_value() {
+ ZX_ASSERT(ordinal() == Ordinal::kIntValue);
+ return *static_cast<int64_t*>(envelope_.data);
+ }
+ const int64_t& int_value() const {
+ ZX_ASSERT(ordinal() == Ordinal::kIntValue);
+ return *static_cast<int64_t*>(envelope_.data);
+ }
+
+ bool is_double_value() const { return ordinal() == Ordinal::kDoubleValue; }
+
+ static Value WithDoubleValue(double* val) {
+ Value result;
+ result.set_double_value(val);
+ return result;
+ }
+
+ void set_double_value(double* elem) {
+ ordinal_ = Ordinal::kDoubleValue;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ double& mutable_double_value() {
+ ZX_ASSERT(ordinal() == Ordinal::kDoubleValue);
+ return *static_cast<double*>(envelope_.data);
+ }
+ const double& double_value() const {
+ ZX_ASSERT(ordinal() == Ordinal::kDoubleValue);
+ return *static_cast<double*>(envelope_.data);
+ }
+
+ bool is_index_value() const { return ordinal() == Ordinal::kIndexValue; }
+
+ static Value WithIndexValue(uint32_t* val) {
+ Value result;
+ result.set_index_value(val);
+ return result;
+ }
+
+ void set_index_value(uint32_t* elem) {
+ ordinal_ = Ordinal::kIndexValue;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ uint32_t& mutable_index_value() {
+ ZX_ASSERT(ordinal() == Ordinal::kIndexValue);
+ return *static_cast<uint32_t*>(envelope_.data);
+ }
+ const uint32_t& index_value() const {
+ ZX_ASSERT(ordinal() == Ordinal::kIndexValue);
+ return *static_cast<uint32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ValueTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kStringValue = 1, // 0x1
+ kIntValue = 2, // 0x2
+ kDoubleValue = 3, // 0x3
+ kIndexValue = 4, // 0x4
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_EventPayloadTable;
+
+struct EventPayload {
+ EventPayload() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kEvent = 1, // 0x1
+ kEventCount = 2, // 0x2
+ kElapsedMicros = 3, // 0x3
+ kFps = 4, // 0x4
+ kMemoryBytesUsed = 5, // 0x5
+ kIntHistogram = 7, // 0x7
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_event() const { return ordinal() == Ordinal::kEvent; }
+
+ static EventPayload WithEvent(::llcpp::fuchsia::cobalt::Event* val) {
+ EventPayload result;
+ result.set_event(val);
+ return result;
+ }
+
+ void set_event(::llcpp::fuchsia::cobalt::Event* elem) {
+ ordinal_ = Ordinal::kEvent;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::cobalt::Event& mutable_event() {
+ ZX_ASSERT(ordinal() == Ordinal::kEvent);
+ return *static_cast<::llcpp::fuchsia::cobalt::Event*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::cobalt::Event& event() const {
+ ZX_ASSERT(ordinal() == Ordinal::kEvent);
+ return *static_cast<::llcpp::fuchsia::cobalt::Event*>(envelope_.data);
+ }
+
+ bool is_event_count() const { return ordinal() == Ordinal::kEventCount; }
+
+ static EventPayload WithEventCount(::llcpp::fuchsia::cobalt::CountEvent* val) {
+ EventPayload result;
+ result.set_event_count(val);
+ return result;
+ }
+
+ void set_event_count(::llcpp::fuchsia::cobalt::CountEvent* elem) {
+ ordinal_ = Ordinal::kEventCount;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::cobalt::CountEvent& mutable_event_count() {
+ ZX_ASSERT(ordinal() == Ordinal::kEventCount);
+ return *static_cast<::llcpp::fuchsia::cobalt::CountEvent*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::cobalt::CountEvent& event_count() const {
+ ZX_ASSERT(ordinal() == Ordinal::kEventCount);
+ return *static_cast<::llcpp::fuchsia::cobalt::CountEvent*>(envelope_.data);
+ }
+
+ bool is_elapsed_micros() const { return ordinal() == Ordinal::kElapsedMicros; }
+
+ static EventPayload WithElapsedMicros(int64_t* val) {
+ EventPayload result;
+ result.set_elapsed_micros(val);
+ return result;
+ }
+
+ void set_elapsed_micros(int64_t* elem) {
+ ordinal_ = Ordinal::kElapsedMicros;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int64_t& mutable_elapsed_micros() {
+ ZX_ASSERT(ordinal() == Ordinal::kElapsedMicros);
+ return *static_cast<int64_t*>(envelope_.data);
+ }
+ const int64_t& elapsed_micros() const {
+ ZX_ASSERT(ordinal() == Ordinal::kElapsedMicros);
+ return *static_cast<int64_t*>(envelope_.data);
+ }
+
+ bool is_fps() const { return ordinal() == Ordinal::kFps; }
+
+ static EventPayload WithFps(float* val) {
+ EventPayload result;
+ result.set_fps(val);
+ return result;
+ }
+
+ void set_fps(float* elem) {
+ ordinal_ = Ordinal::kFps;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ float& mutable_fps() {
+ ZX_ASSERT(ordinal() == Ordinal::kFps);
+ return *static_cast<float*>(envelope_.data);
+ }
+ const float& fps() const {
+ ZX_ASSERT(ordinal() == Ordinal::kFps);
+ return *static_cast<float*>(envelope_.data);
+ }
+
+ bool is_memory_bytes_used() const { return ordinal() == Ordinal::kMemoryBytesUsed; }
+
+ static EventPayload WithMemoryBytesUsed(int64_t* val) {
+ EventPayload result;
+ result.set_memory_bytes_used(val);
+ return result;
+ }
+
+ void set_memory_bytes_used(int64_t* elem) {
+ ordinal_ = Ordinal::kMemoryBytesUsed;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int64_t& mutable_memory_bytes_used() {
+ ZX_ASSERT(ordinal() == Ordinal::kMemoryBytesUsed);
+ return *static_cast<int64_t*>(envelope_.data);
+ }
+ const int64_t& memory_bytes_used() const {
+ ZX_ASSERT(ordinal() == Ordinal::kMemoryBytesUsed);
+ return *static_cast<int64_t*>(envelope_.data);
+ }
+
+ bool is_int_histogram() const { return ordinal() == Ordinal::kIntHistogram; }
+
+ static EventPayload WithIntHistogram(::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket>* val) {
+ EventPayload result;
+ result.set_int_histogram(val);
+ return result;
+ }
+
+ void set_int_histogram(::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket>* elem) {
+ ordinal_ = Ordinal::kIntHistogram;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket>& mutable_int_histogram() {
+ ZX_ASSERT(ordinal() == Ordinal::kIntHistogram);
+ return *static_cast<::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket>*>(envelope_.data);
+ }
+ const ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket>& int_histogram() const {
+ ZX_ASSERT(ordinal() == Ordinal::kIntHistogram);
+ return *static_cast<::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket>*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_EventPayloadTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8016;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kEvent = 1, // 0x1
+ kEventCount = 2, // 0x2
+ kElapsedMicros = 3, // 0x3
+ kFps = 4, // 0x4
+ kMemoryBytesUsed = 5, // 0x5
+ kIntHistogram = 7, // 0x7
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_CustomEventValueTable;
+
+// Logger Interface
+struct CustomEventValue {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_CustomEventValueTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::StringView dimension_name = {};
+
+ ::llcpp::fuchsia::cobalt::Value value = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerRequestSendSoonRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerRequestSendSoonResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerBlockUntilEmptyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerBlockUntilEmptyResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetNumSendAttemptsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetNumSendAttemptsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetFailedSendAttemptsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetFailedSendAttemptsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetNumObservationsAddedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGetNumObservationsAddedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGenerateAggregatedObservationsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ControllerGenerateAggregatedObservationsResponseTable;
+
+class Controller final {
+ Controller() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.cobalt.Controller";
+
+ struct RequestSendSoonResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool success;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ControllerRequestSendSoonResponseTable;
+ 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 RequestSendSoonRequest = ::fidl::AnyZeroArgMessage;
+
+ using BlockUntilEmptyResponse = ::fidl::AnyZeroArgMessage;
+ struct BlockUntilEmptyRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t max_wait_seconds;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ControllerBlockUntilEmptyRequestTable;
+ 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;
+ };
+
+ struct GetNumSendAttemptsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t num;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ControllerGetNumSendAttemptsResponseTable;
+ 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 GetNumSendAttemptsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetFailedSendAttemptsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t num;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ControllerGetFailedSendAttemptsResponseTable;
+ 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 GetFailedSendAttemptsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetNumObservationsAddedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t num_obs;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ControllerGetNumObservationsAddedResponseTable;
+ 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 GetNumObservationsAddedRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GenerateAggregatedObservationsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint64_t> num_obs;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ControllerGenerateAggregatedObservationsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ 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 GenerateAggregatedObservationsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t day_index;
+ ::fidl::VectorView<uint32_t> report_ids;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ControllerGenerateAggregatedObservationsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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 = GenerateAggregatedObservationsResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class RequestSendSoon_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RequestSendSoon_Impl(::zx::unowned_channel _client_end);
+ ~RequestSendSoon_Impl() = default;
+ RequestSendSoon_Impl(RequestSendSoon_Impl&& other) = default;
+ RequestSendSoon_Impl& operator=(RequestSendSoon_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 BlockUntilEmpty_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ BlockUntilEmpty_Impl(::zx::unowned_channel _client_end, uint32_t max_wait_seconds);
+ ~BlockUntilEmpty_Impl() = default;
+ BlockUntilEmpty_Impl(BlockUntilEmpty_Impl&& other) = default;
+ BlockUntilEmpty_Impl& operator=(BlockUntilEmpty_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 GetNumSendAttempts_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetNumSendAttempts_Impl(::zx::unowned_channel _client_end);
+ ~GetNumSendAttempts_Impl() = default;
+ GetNumSendAttempts_Impl(GetNumSendAttempts_Impl&& other) = default;
+ GetNumSendAttempts_Impl& operator=(GetNumSendAttempts_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 GetFailedSendAttempts_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetFailedSendAttempts_Impl(::zx::unowned_channel _client_end);
+ ~GetFailedSendAttempts_Impl() = default;
+ GetFailedSendAttempts_Impl(GetFailedSendAttempts_Impl&& other) = default;
+ GetFailedSendAttempts_Impl& operator=(GetFailedSendAttempts_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 GetNumObservationsAdded_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetNumObservationsAdded_Impl(::zx::unowned_channel _client_end);
+ ~GetNumObservationsAdded_Impl() = default;
+ GetNumObservationsAdded_Impl(GetNumObservationsAdded_Impl&& other) = default;
+ GetNumObservationsAdded_Impl& operator=(GetNumObservationsAdded_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 GenerateAggregatedObservations_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GenerateAggregatedObservations_Impl(::zx::unowned_channel _client_end, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids);
+ ~GenerateAggregatedObservations_Impl() = default;
+ GenerateAggregatedObservations_Impl(GenerateAggregatedObservations_Impl&& other) = default;
+ GenerateAggregatedObservations_Impl& operator=(GenerateAggregatedObservations_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 RequestSendSoon = RequestSendSoon_Impl<RequestSendSoonResponse>;
+ using BlockUntilEmpty = BlockUntilEmpty_Impl<BlockUntilEmptyResponse>;
+ using GetNumSendAttempts = GetNumSendAttempts_Impl<GetNumSendAttemptsResponse>;
+ using GetFailedSendAttempts = GetFailedSendAttempts_Impl<GetFailedSendAttemptsResponse>;
+ using GetNumObservationsAdded = GetNumObservationsAdded_Impl<GetNumObservationsAddedResponse>;
+ using GenerateAggregatedObservations = GenerateAggregatedObservations_Impl<GenerateAggregatedObservationsResponse>;
+ };
+
+ // 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 RequestSendSoon_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RequestSendSoon_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~RequestSendSoon_Impl() = default;
+ RequestSendSoon_Impl(RequestSendSoon_Impl&& other) = default;
+ RequestSendSoon_Impl& operator=(RequestSendSoon_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 BlockUntilEmpty_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ BlockUntilEmpty_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t max_wait_seconds, ::fidl::BytePart _response_buffer);
+ ~BlockUntilEmpty_Impl() = default;
+ BlockUntilEmpty_Impl(BlockUntilEmpty_Impl&& other) = default;
+ BlockUntilEmpty_Impl& operator=(BlockUntilEmpty_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 GetNumSendAttempts_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetNumSendAttempts_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetNumSendAttempts_Impl() = default;
+ GetNumSendAttempts_Impl(GetNumSendAttempts_Impl&& other) = default;
+ GetNumSendAttempts_Impl& operator=(GetNumSendAttempts_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 GetFailedSendAttempts_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetFailedSendAttempts_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetFailedSendAttempts_Impl() = default;
+ GetFailedSendAttempts_Impl(GetFailedSendAttempts_Impl&& other) = default;
+ GetFailedSendAttempts_Impl& operator=(GetFailedSendAttempts_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 GetNumObservationsAdded_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetNumObservationsAdded_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetNumObservationsAdded_Impl() = default;
+ GetNumObservationsAdded_Impl(GetNumObservationsAdded_Impl&& other) = default;
+ GetNumObservationsAdded_Impl& operator=(GetNumObservationsAdded_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 GenerateAggregatedObservations_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GenerateAggregatedObservations_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids, ::fidl::BytePart _response_buffer);
+ ~GenerateAggregatedObservations_Impl() = default;
+ GenerateAggregatedObservations_Impl(GenerateAggregatedObservations_Impl&& other) = default;
+ GenerateAggregatedObservations_Impl& operator=(GenerateAggregatedObservations_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 RequestSendSoon = RequestSendSoon_Impl<RequestSendSoonResponse>;
+ using BlockUntilEmpty = BlockUntilEmpty_Impl<BlockUntilEmptyResponse>;
+ using GetNumSendAttempts = GetNumSendAttempts_Impl<GetNumSendAttemptsResponse>;
+ using GetFailedSendAttempts = GetFailedSendAttempts_Impl<GetFailedSendAttemptsResponse>;
+ using GetNumObservationsAdded = GetNumObservationsAdded_Impl<GetNumObservationsAddedResponse>;
+ using GenerateAggregatedObservations = GenerateAggregatedObservations_Impl<GenerateAggregatedObservationsResponse>;
+ };
+
+ 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 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RequestSendSoon RequestSendSoon();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RequestSendSoon RequestSendSoon(::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::BlockUntilEmpty BlockUntilEmpty(uint32_t max_wait_seconds);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::BlockUntilEmpty BlockUntilEmpty(::fidl::BytePart _request_buffer, uint32_t max_wait_seconds, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetNumSendAttempts GetNumSendAttempts();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetNumSendAttempts GetNumSendAttempts(::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetFailedSendAttempts GetFailedSendAttempts();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetFailedSendAttempts GetFailedSendAttempts(::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetNumObservationsAdded GetNumObservationsAdded();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetNumObservationsAdded GetNumObservationsAdded(::fidl::BytePart _response_buffer);
+
+ // Request is heap-allocated. Response is heap-allocated.
+ ResultOf::GenerateAggregatedObservations GenerateAggregatedObservations(uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GenerateAggregatedObservations GenerateAggregatedObservations(::fidl::BytePart _request_buffer, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids, ::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 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RequestSendSoon RequestSendSoon(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RequestSendSoon RequestSendSoon(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::BlockUntilEmpty BlockUntilEmpty(::zx::unowned_channel _client_end, uint32_t max_wait_seconds);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::BlockUntilEmpty BlockUntilEmpty(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t max_wait_seconds, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetNumSendAttempts GetNumSendAttempts(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetNumSendAttempts GetNumSendAttempts(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetFailedSendAttempts GetFailedSendAttempts(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetFailedSendAttempts GetFailedSendAttempts(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetNumObservationsAdded GetNumObservationsAdded(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetNumObservationsAdded GetNumObservationsAdded(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Request is heap-allocated. Response is heap-allocated.
+ static ResultOf::GenerateAggregatedObservations GenerateAggregatedObservations(::zx::unowned_channel _client_end, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GenerateAggregatedObservations GenerateAggregatedObservations(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids, ::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<RequestSendSoonResponse> RequestSendSoon(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<BlockUntilEmptyResponse> BlockUntilEmpty(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BlockUntilEmptyRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetNumSendAttemptsResponse> GetNumSendAttempts(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetFailedSendAttemptsResponse> GetFailedSendAttempts(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetNumObservationsAddedResponse> GetNumObservationsAdded(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GenerateAggregatedObservationsResponse> GenerateAggregatedObservations(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GenerateAggregatedObservationsRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Controller;
+ using _Base = ::fidl::CompleterBase;
+
+ class RequestSendSoonCompleterBase : public _Base {
+ public:
+ void Reply(bool success);
+ void Reply(::fidl::BytePart _buffer, bool success);
+ void Reply(::fidl::DecodedMessage<RequestSendSoonResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RequestSendSoonCompleter = ::fidl::Completer<RequestSendSoonCompleterBase>;
+
+ virtual void RequestSendSoon(RequestSendSoonCompleter::Sync _completer) = 0;
+
+ class BlockUntilEmptyCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BlockUntilEmptyCompleter = ::fidl::Completer<BlockUntilEmptyCompleterBase>;
+
+ virtual void BlockUntilEmpty(uint32_t max_wait_seconds, BlockUntilEmptyCompleter::Sync _completer) = 0;
+
+ class GetNumSendAttemptsCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t num);
+ void Reply(::fidl::BytePart _buffer, uint32_t num);
+ void Reply(::fidl::DecodedMessage<GetNumSendAttemptsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetNumSendAttemptsCompleter = ::fidl::Completer<GetNumSendAttemptsCompleterBase>;
+
+ virtual void GetNumSendAttempts(GetNumSendAttemptsCompleter::Sync _completer) = 0;
+
+ class GetFailedSendAttemptsCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t num);
+ void Reply(::fidl::BytePart _buffer, uint32_t num);
+ void Reply(::fidl::DecodedMessage<GetFailedSendAttemptsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetFailedSendAttemptsCompleter = ::fidl::Completer<GetFailedSendAttemptsCompleterBase>;
+
+ virtual void GetFailedSendAttempts(GetFailedSendAttemptsCompleter::Sync _completer) = 0;
+
+ class GetNumObservationsAddedCompleterBase : public _Base {
+ public:
+ void Reply(uint64_t num_obs);
+ void Reply(::fidl::BytePart _buffer, uint64_t num_obs);
+ void Reply(::fidl::DecodedMessage<GetNumObservationsAddedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetNumObservationsAddedCompleter = ::fidl::Completer<GetNumObservationsAddedCompleterBase>;
+
+ virtual void GetNumObservationsAdded(GetNumObservationsAddedCompleter::Sync _completer) = 0;
+
+ class GenerateAggregatedObservationsCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<uint64_t> num_obs);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<uint64_t> num_obs);
+ void Reply(::fidl::DecodedMessage<GenerateAggregatedObservationsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GenerateAggregatedObservationsCompleter = ::fidl::Completer<GenerateAggregatedObservationsCompleterBase>;
+
+ virtual void GenerateAggregatedObservations(uint32_t day_index, ::fidl::VectorView<uint32_t> report_ids, GenerateAggregatedObservationsCompleter::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 RequestSendSoonRequest(const ::fidl::DecodedMessage<Controller::RequestSendSoonRequest>& _msg);
+ static void RequestSendSoonResponse(const ::fidl::DecodedMessage<Controller::RequestSendSoonResponse>& _msg);
+ static void BlockUntilEmptyRequest(const ::fidl::DecodedMessage<Controller::BlockUntilEmptyRequest>& _msg);
+ static void BlockUntilEmptyResponse(const ::fidl::DecodedMessage<Controller::BlockUntilEmptyResponse>& _msg);
+ static void GetNumSendAttemptsRequest(const ::fidl::DecodedMessage<Controller::GetNumSendAttemptsRequest>& _msg);
+ static void GetNumSendAttemptsResponse(const ::fidl::DecodedMessage<Controller::GetNumSendAttemptsResponse>& _msg);
+ static void GetFailedSendAttemptsRequest(const ::fidl::DecodedMessage<Controller::GetFailedSendAttemptsRequest>& _msg);
+ static void GetFailedSendAttemptsResponse(const ::fidl::DecodedMessage<Controller::GetFailedSendAttemptsResponse>& _msg);
+ static void GetNumObservationsAddedRequest(const ::fidl::DecodedMessage<Controller::GetNumObservationsAddedRequest>& _msg);
+ static void GetNumObservationsAddedResponse(const ::fidl::DecodedMessage<Controller::GetNumObservationsAddedResponse>& _msg);
+ static void GenerateAggregatedObservationsRequest(const ::fidl::DecodedMessage<Controller::GenerateAggregatedObservationsRequest>& _msg);
+ static void GenerateAggregatedObservationsResponse(const ::fidl::DecodedMessage<Controller::GenerateAggregatedObservationsResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogEventCountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogEventCountResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogElapsedTimeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogElapsedTimeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogFrameRateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogFrameRateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogMemoryUsageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseLogMemoryUsageResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseStartTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseStartTimerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseEndTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerBaseEndTimerResponseTable;
+
+// LoggerBase Interface
+class LoggerBase final {
+ LoggerBase() = delete;
+ public:
+
+ struct LogEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogEventResponseTable;
+ 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 LogEventRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogEventRequestTable;
+ 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 = LogEventResponse;
+ };
+
+ struct LogEventCountResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogEventCountResponseTable;
+ 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 LogEventCountRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t period_duration_micros;
+ int64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogEventCountRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogEventCountResponse;
+ };
+
+ struct LogElapsedTimeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogElapsedTimeResponseTable;
+ 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 LogElapsedTimeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t elapsed_micros;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogElapsedTimeRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogElapsedTimeResponse;
+ };
+
+ struct LogFrameRateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogFrameRateResponseTable;
+ 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 LogFrameRateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ float fps;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogFrameRateRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogFrameRateResponse;
+ };
+
+ struct LogMemoryUsageResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogMemoryUsageResponseTable;
+ 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 LogMemoryUsageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t bytes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseLogMemoryUsageRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogMemoryUsageResponse;
+ };
+
+ struct StartTimerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseStartTimerResponseTable;
+ 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 StartTimerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ ::fidl::StringView timer_id;
+ uint64_t timestamp;
+ uint32_t timeout_s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseStartTimerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 72;
+ static constexpr uint32_t MaxOutOfLine = 128;
+ static constexpr uint32_t AltPrimarySize = 72;
+ 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 = StartTimerResponse;
+ };
+
+ struct EndTimerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseEndTimerResponseTable;
+ 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 EndTimerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView timer_id;
+ uint64_t timestamp;
+ uint32_t timeout_s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerBaseEndTimerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = EndTimerResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class LogEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogEvent_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code);
+ ~LogEvent_Impl() = default;
+ LogEvent_Impl(LogEvent_Impl&& other) = default;
+ LogEvent_Impl& operator=(LogEvent_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 LogEventCount_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogEventCount_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+ ~LogEventCount_Impl() = default;
+ LogEventCount_Impl(LogEventCount_Impl&& other) = default;
+ LogEventCount_Impl& operator=(LogEventCount_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 LogElapsedTime_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogElapsedTime_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+ ~LogElapsedTime_Impl() = default;
+ LogElapsedTime_Impl(LogElapsedTime_Impl&& other) = default;
+ LogElapsedTime_Impl& operator=(LogElapsedTime_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 LogFrameRate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogFrameRate_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+ ~LogFrameRate_Impl() = default;
+ LogFrameRate_Impl(LogFrameRate_Impl&& other) = default;
+ LogFrameRate_Impl& operator=(LogFrameRate_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 LogMemoryUsage_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogMemoryUsage_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+ ~LogMemoryUsage_Impl() = default;
+ LogMemoryUsage_Impl(LogMemoryUsage_Impl&& other) = default;
+ LogMemoryUsage_Impl& operator=(LogMemoryUsage_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 StartTimer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ StartTimer_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+ ~StartTimer_Impl() = default;
+ StartTimer_Impl(StartTimer_Impl&& other) = default;
+ StartTimer_Impl& operator=(StartTimer_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 EndTimer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+ ~EndTimer_Impl() = default;
+ EndTimer_Impl(EndTimer_Impl&& other) = default;
+ EndTimer_Impl& operator=(EndTimer_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 LogEvent = LogEvent_Impl<LogEventResponse>;
+ using LogEventCount = LogEventCount_Impl<LogEventCountResponse>;
+ using LogElapsedTime = LogElapsedTime_Impl<LogElapsedTimeResponse>;
+ using LogFrameRate = LogFrameRate_Impl<LogFrameRateResponse>;
+ using LogMemoryUsage = LogMemoryUsage_Impl<LogMemoryUsageResponse>;
+ using StartTimer = StartTimer_Impl<StartTimerResponse>;
+ using EndTimer = EndTimer_Impl<EndTimerResponse>;
+ };
+
+ // 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 LogEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+ ~LogEvent_Impl() = default;
+ LogEvent_Impl(LogEvent_Impl&& other) = default;
+ LogEvent_Impl& operator=(LogEvent_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 LogEventCount_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogEventCount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+ ~LogEventCount_Impl() = default;
+ LogEventCount_Impl(LogEventCount_Impl&& other) = default;
+ LogEventCount_Impl& operator=(LogEventCount_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 LogElapsedTime_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogElapsedTime_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+ ~LogElapsedTime_Impl() = default;
+ LogElapsedTime_Impl(LogElapsedTime_Impl&& other) = default;
+ LogElapsedTime_Impl& operator=(LogElapsedTime_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 LogFrameRate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogFrameRate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+ ~LogFrameRate_Impl() = default;
+ LogFrameRate_Impl(LogFrameRate_Impl&& other) = default;
+ LogFrameRate_Impl& operator=(LogFrameRate_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 LogMemoryUsage_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogMemoryUsage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+ ~LogMemoryUsage_Impl() = default;
+ LogMemoryUsage_Impl(LogMemoryUsage_Impl&& other) = default;
+ LogMemoryUsage_Impl& operator=(LogMemoryUsage_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 StartTimer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ StartTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+ ~StartTimer_Impl() = default;
+ StartTimer_Impl(StartTimer_Impl&& other) = default;
+ StartTimer_Impl& operator=(StartTimer_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 EndTimer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+ ~EndTimer_Impl() = default;
+ EndTimer_Impl(EndTimer_Impl&& other) = default;
+ EndTimer_Impl& operator=(EndTimer_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 LogEvent = LogEvent_Impl<LogEventResponse>;
+ using LogEventCount = LogEventCount_Impl<LogEventCountResponse>;
+ using LogElapsedTime = LogElapsedTime_Impl<LogElapsedTimeResponse>;
+ using LogFrameRate = LogFrameRate_Impl<LogFrameRateResponse>;
+ using LogMemoryUsage = LogMemoryUsage_Impl<LogMemoryUsageResponse>;
+ using StartTimer = StartTimer_Impl<StartTimerResponse>;
+ using EndTimer = EndTimer_Impl<EndTimerResponse>;
+ };
+
+ 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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogEvent LogEvent(uint32_t metric_id, uint32_t event_code);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogEvent LogEvent(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogEventCount LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogEventCount LogEventCount(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogElapsedTime LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogElapsedTime LogElapsedTime(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogFrameRate LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogFrameRate LogFrameRate(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogMemoryUsage LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogMemoryUsage LogMemoryUsage(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+
+ // Allocates 224 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::StartTimer StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::StartTimer StartTimer(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::EndTimer EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::EndTimer EndTimer(::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogEvent LogEvent(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogEvent LogEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogEventCount LogEventCount(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogEventCount LogEventCount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogElapsedTime LogElapsedTime(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogElapsedTime LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogFrameRate LogFrameRate(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogFrameRate LogFrameRate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogMemoryUsage LogMemoryUsage(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogMemoryUsage LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+
+ // Allocates 224 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::StartTimer StartTimer(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::StartTimer StartTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::EndTimer EndTimer(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::EndTimer EndTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::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<LogEventResponse> LogEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogEventCountResponse> LogEventCount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventCountRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogElapsedTimeResponse> LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogElapsedTimeRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogFrameRateResponse> LogFrameRate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogFrameRateRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogMemoryUsageResponse> LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogMemoryUsageRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<StartTimerResponse> StartTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StartTimerRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<EndTimerResponse> EndTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EndTimerRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = LoggerBase;
+ using _Base = ::fidl::CompleterBase;
+
+ class LogEventCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogEventCompleter = ::fidl::Completer<LogEventCompleterBase>;
+
+ virtual void LogEvent(uint32_t metric_id, uint32_t event_code, LogEventCompleter::Sync _completer) = 0;
+
+ class LogEventCountCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogEventCountResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogEventCountCompleter = ::fidl::Completer<LogEventCountCompleterBase>;
+
+ virtual void LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, LogEventCountCompleter::Sync _completer) = 0;
+
+ class LogElapsedTimeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogElapsedTimeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogElapsedTimeCompleter = ::fidl::Completer<LogElapsedTimeCompleterBase>;
+
+ virtual void LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, LogElapsedTimeCompleter::Sync _completer) = 0;
+
+ class LogFrameRateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogFrameRateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogFrameRateCompleter = ::fidl::Completer<LogFrameRateCompleterBase>;
+
+ virtual void LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, LogFrameRateCompleter::Sync _completer) = 0;
+
+ class LogMemoryUsageCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogMemoryUsageResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogMemoryUsageCompleter = ::fidl::Completer<LogMemoryUsageCompleterBase>;
+
+ virtual void LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, LogMemoryUsageCompleter::Sync _completer) = 0;
+
+ class StartTimerCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<StartTimerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StartTimerCompleter = ::fidl::Completer<StartTimerCompleterBase>;
+
+ virtual void StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, StartTimerCompleter::Sync _completer) = 0;
+
+ class EndTimerCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<EndTimerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using EndTimerCompleter = ::fidl::Completer<EndTimerCompleterBase>;
+
+ virtual void EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, EndTimerCompleter::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 LogEventRequest(const ::fidl::DecodedMessage<LoggerBase::LogEventRequest>& _msg);
+ static void LogEventResponse(const ::fidl::DecodedMessage<LoggerBase::LogEventResponse>& _msg);
+ static void LogEventCountRequest(const ::fidl::DecodedMessage<LoggerBase::LogEventCountRequest>& _msg);
+ static void LogEventCountResponse(const ::fidl::DecodedMessage<LoggerBase::LogEventCountResponse>& _msg);
+ static void LogElapsedTimeRequest(const ::fidl::DecodedMessage<LoggerBase::LogElapsedTimeRequest>& _msg);
+ static void LogElapsedTimeResponse(const ::fidl::DecodedMessage<LoggerBase::LogElapsedTimeResponse>& _msg);
+ static void LogFrameRateRequest(const ::fidl::DecodedMessage<LoggerBase::LogFrameRateRequest>& _msg);
+ static void LogFrameRateResponse(const ::fidl::DecodedMessage<LoggerBase::LogFrameRateResponse>& _msg);
+ static void LogMemoryUsageRequest(const ::fidl::DecodedMessage<LoggerBase::LogMemoryUsageRequest>& _msg);
+ static void LogMemoryUsageResponse(const ::fidl::DecodedMessage<LoggerBase::LogMemoryUsageResponse>& _msg);
+ static void StartTimerRequest(const ::fidl::DecodedMessage<LoggerBase::StartTimerRequest>& _msg);
+ static void StartTimerResponse(const ::fidl::DecodedMessage<LoggerBase::StartTimerResponse>& _msg);
+ static void EndTimerRequest(const ::fidl::DecodedMessage<LoggerBase::EndTimerRequest>& _msg);
+ static void EndTimerResponse(const ::fidl::DecodedMessage<LoggerBase::EndTimerResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogEventCountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogEventCountResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogElapsedTimeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogElapsedTimeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogFrameRateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogFrameRateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogMemoryUsageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogMemoryUsageResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleStartTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleStartTimerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleEndTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleEndTimerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogIntHistogramRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerSimpleLogIntHistogramResponseTable;
+
+// LoggerSimple Interface
+class LoggerSimple final {
+ LoggerSimple() = delete;
+ public:
+
+ struct LogEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogEventResponseTable;
+ 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 LogEventRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogEventRequestTable;
+ 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 = LogEventResponse;
+ };
+
+ struct LogEventCountResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogEventCountResponseTable;
+ 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 LogEventCountRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t period_duration_micros;
+ int64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogEventCountRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogEventCountResponse;
+ };
+
+ struct LogElapsedTimeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogElapsedTimeResponseTable;
+ 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 LogElapsedTimeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t elapsed_micros;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogElapsedTimeRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogElapsedTimeResponse;
+ };
+
+ struct LogFrameRateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogFrameRateResponseTable;
+ 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 LogFrameRateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ float fps;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogFrameRateRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogFrameRateResponse;
+ };
+
+ struct LogMemoryUsageResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogMemoryUsageResponseTable;
+ 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 LogMemoryUsageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t bytes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogMemoryUsageRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogMemoryUsageResponse;
+ };
+
+ struct StartTimerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleStartTimerResponseTable;
+ 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 StartTimerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ ::fidl::StringView timer_id;
+ uint64_t timestamp;
+ uint32_t timeout_s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleStartTimerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 72;
+ static constexpr uint32_t MaxOutOfLine = 128;
+ static constexpr uint32_t AltPrimarySize = 72;
+ 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 = StartTimerResponse;
+ };
+
+ struct EndTimerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleEndTimerResponseTable;
+ 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 EndTimerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView timer_id;
+ uint64_t timestamp;
+ uint32_t timeout_s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleEndTimerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = EndTimerResponse;
+ };
+
+ struct LogIntHistogramResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogIntHistogramResponseTable;
+ 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 LogIntHistogramRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ ::fidl::VectorView<uint32_t> bucket_indices;
+ ::fidl::VectorView<uint64_t> bucket_counts;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerSimpleLogIntHistogramRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 72;
+ static constexpr uint32_t MaxOutOfLine = 6064;
+ static constexpr uint32_t AltPrimarySize = 72;
+ static constexpr uint32_t AltMaxOutOfLine = 6064;
+ 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 = LogIntHistogramResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class LogEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogEvent_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code);
+ ~LogEvent_Impl() = default;
+ LogEvent_Impl(LogEvent_Impl&& other) = default;
+ LogEvent_Impl& operator=(LogEvent_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 LogEventCount_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogEventCount_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+ ~LogEventCount_Impl() = default;
+ LogEventCount_Impl(LogEventCount_Impl&& other) = default;
+ LogEventCount_Impl& operator=(LogEventCount_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 LogElapsedTime_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogElapsedTime_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+ ~LogElapsedTime_Impl() = default;
+ LogElapsedTime_Impl(LogElapsedTime_Impl&& other) = default;
+ LogElapsedTime_Impl& operator=(LogElapsedTime_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 LogFrameRate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogFrameRate_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+ ~LogFrameRate_Impl() = default;
+ LogFrameRate_Impl(LogFrameRate_Impl&& other) = default;
+ LogFrameRate_Impl& operator=(LogFrameRate_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 LogMemoryUsage_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogMemoryUsage_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+ ~LogMemoryUsage_Impl() = default;
+ LogMemoryUsage_Impl(LogMemoryUsage_Impl&& other) = default;
+ LogMemoryUsage_Impl& operator=(LogMemoryUsage_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 StartTimer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ StartTimer_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+ ~StartTimer_Impl() = default;
+ StartTimer_Impl(StartTimer_Impl&& other) = default;
+ StartTimer_Impl& operator=(StartTimer_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 EndTimer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+ ~EndTimer_Impl() = default;
+ EndTimer_Impl(EndTimer_Impl&& other) = default;
+ EndTimer_Impl& operator=(EndTimer_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 LogIntHistogram_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogIntHistogram_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts);
+ ~LogIntHistogram_Impl() = default;
+ LogIntHistogram_Impl(LogIntHistogram_Impl&& other) = default;
+ LogIntHistogram_Impl& operator=(LogIntHistogram_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 LogEvent = LogEvent_Impl<LogEventResponse>;
+ using LogEventCount = LogEventCount_Impl<LogEventCountResponse>;
+ using LogElapsedTime = LogElapsedTime_Impl<LogElapsedTimeResponse>;
+ using LogFrameRate = LogFrameRate_Impl<LogFrameRateResponse>;
+ using LogMemoryUsage = LogMemoryUsage_Impl<LogMemoryUsageResponse>;
+ using StartTimer = StartTimer_Impl<StartTimerResponse>;
+ using EndTimer = EndTimer_Impl<EndTimerResponse>;
+ using LogIntHistogram = LogIntHistogram_Impl<LogIntHistogramResponse>;
+ };
+
+ // 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 LogEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+ ~LogEvent_Impl() = default;
+ LogEvent_Impl(LogEvent_Impl&& other) = default;
+ LogEvent_Impl& operator=(LogEvent_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 LogEventCount_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogEventCount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+ ~LogEventCount_Impl() = default;
+ LogEventCount_Impl(LogEventCount_Impl&& other) = default;
+ LogEventCount_Impl& operator=(LogEventCount_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 LogElapsedTime_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogElapsedTime_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+ ~LogElapsedTime_Impl() = default;
+ LogElapsedTime_Impl(LogElapsedTime_Impl&& other) = default;
+ LogElapsedTime_Impl& operator=(LogElapsedTime_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 LogFrameRate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogFrameRate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+ ~LogFrameRate_Impl() = default;
+ LogFrameRate_Impl(LogFrameRate_Impl&& other) = default;
+ LogFrameRate_Impl& operator=(LogFrameRate_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 LogMemoryUsage_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogMemoryUsage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+ ~LogMemoryUsage_Impl() = default;
+ LogMemoryUsage_Impl(LogMemoryUsage_Impl&& other) = default;
+ LogMemoryUsage_Impl& operator=(LogMemoryUsage_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 StartTimer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ StartTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+ ~StartTimer_Impl() = default;
+ StartTimer_Impl(StartTimer_Impl&& other) = default;
+ StartTimer_Impl& operator=(StartTimer_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 EndTimer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+ ~EndTimer_Impl() = default;
+ EndTimer_Impl(EndTimer_Impl&& other) = default;
+ EndTimer_Impl& operator=(EndTimer_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 LogIntHistogram_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogIntHistogram_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts, ::fidl::BytePart _response_buffer);
+ ~LogIntHistogram_Impl() = default;
+ LogIntHistogram_Impl(LogIntHistogram_Impl&& other) = default;
+ LogIntHistogram_Impl& operator=(LogIntHistogram_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 LogEvent = LogEvent_Impl<LogEventResponse>;
+ using LogEventCount = LogEventCount_Impl<LogEventCountResponse>;
+ using LogElapsedTime = LogElapsedTime_Impl<LogElapsedTimeResponse>;
+ using LogFrameRate = LogFrameRate_Impl<LogFrameRateResponse>;
+ using LogMemoryUsage = LogMemoryUsage_Impl<LogMemoryUsageResponse>;
+ using StartTimer = StartTimer_Impl<StartTimerResponse>;
+ using EndTimer = EndTimer_Impl<EndTimerResponse>;
+ using LogIntHistogram = LogIntHistogram_Impl<LogIntHistogramResponse>;
+ };
+
+ 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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogEvent LogEvent(uint32_t metric_id, uint32_t event_code);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogEvent LogEvent(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogEventCount LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogEventCount LogEventCount(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogElapsedTime LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogElapsedTime LogElapsedTime(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogFrameRate LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogFrameRate LogFrameRate(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogMemoryUsage LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogMemoryUsage LogMemoryUsage(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+
+ // Allocates 224 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::StartTimer StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::StartTimer StartTimer(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::EndTimer EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::EndTimer EndTimer(::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::LogIntHistogram LogIntHistogram(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogIntHistogram LogIntHistogram(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts, ::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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogEvent LogEvent(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogEvent LogEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogEventCount LogEventCount(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogEventCount LogEventCount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogElapsedTime LogElapsedTime(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogElapsedTime LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogFrameRate LogFrameRate(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogFrameRate LogFrameRate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogMemoryUsage LogMemoryUsage(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogMemoryUsage LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+
+ // Allocates 224 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::StartTimer StartTimer(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::StartTimer StartTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::EndTimer EndTimer(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::EndTimer EndTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::LogIntHistogram LogIntHistogram(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogIntHistogram LogIntHistogram(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts, ::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<LogEventResponse> LogEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogEventCountResponse> LogEventCount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventCountRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogElapsedTimeResponse> LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogElapsedTimeRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogFrameRateResponse> LogFrameRate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogFrameRateRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogMemoryUsageResponse> LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogMemoryUsageRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<StartTimerResponse> StartTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StartTimerRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<EndTimerResponse> EndTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EndTimerRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogIntHistogramResponse> LogIntHistogram(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogIntHistogramRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = LoggerSimple;
+ using _Base = ::fidl::CompleterBase;
+
+ class LogEventCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogEventCompleter = ::fidl::Completer<LogEventCompleterBase>;
+
+ virtual void LogEvent(uint32_t metric_id, uint32_t event_code, LogEventCompleter::Sync _completer) = 0;
+
+ class LogEventCountCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogEventCountResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogEventCountCompleter = ::fidl::Completer<LogEventCountCompleterBase>;
+
+ virtual void LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, LogEventCountCompleter::Sync _completer) = 0;
+
+ class LogElapsedTimeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogElapsedTimeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogElapsedTimeCompleter = ::fidl::Completer<LogElapsedTimeCompleterBase>;
+
+ virtual void LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, LogElapsedTimeCompleter::Sync _completer) = 0;
+
+ class LogFrameRateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogFrameRateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogFrameRateCompleter = ::fidl::Completer<LogFrameRateCompleterBase>;
+
+ virtual void LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, LogFrameRateCompleter::Sync _completer) = 0;
+
+ class LogMemoryUsageCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogMemoryUsageResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogMemoryUsageCompleter = ::fidl::Completer<LogMemoryUsageCompleterBase>;
+
+ virtual void LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, LogMemoryUsageCompleter::Sync _completer) = 0;
+
+ class StartTimerCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<StartTimerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StartTimerCompleter = ::fidl::Completer<StartTimerCompleterBase>;
+
+ virtual void StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, StartTimerCompleter::Sync _completer) = 0;
+
+ class EndTimerCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<EndTimerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using EndTimerCompleter = ::fidl::Completer<EndTimerCompleterBase>;
+
+ virtual void EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, EndTimerCompleter::Sync _completer) = 0;
+
+ class LogIntHistogramCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogIntHistogramResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogIntHistogramCompleter = ::fidl::Completer<LogIntHistogramCompleterBase>;
+
+ virtual void LogIntHistogram(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<uint32_t> bucket_indices, ::fidl::VectorView<uint64_t> bucket_counts, LogIntHistogramCompleter::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 LogEventRequest(const ::fidl::DecodedMessage<LoggerSimple::LogEventRequest>& _msg);
+ static void LogEventResponse(const ::fidl::DecodedMessage<LoggerSimple::LogEventResponse>& _msg);
+ static void LogEventCountRequest(const ::fidl::DecodedMessage<LoggerSimple::LogEventCountRequest>& _msg);
+ static void LogEventCountResponse(const ::fidl::DecodedMessage<LoggerSimple::LogEventCountResponse>& _msg);
+ static void LogElapsedTimeRequest(const ::fidl::DecodedMessage<LoggerSimple::LogElapsedTimeRequest>& _msg);
+ static void LogElapsedTimeResponse(const ::fidl::DecodedMessage<LoggerSimple::LogElapsedTimeResponse>& _msg);
+ static void LogFrameRateRequest(const ::fidl::DecodedMessage<LoggerSimple::LogFrameRateRequest>& _msg);
+ static void LogFrameRateResponse(const ::fidl::DecodedMessage<LoggerSimple::LogFrameRateResponse>& _msg);
+ static void LogMemoryUsageRequest(const ::fidl::DecodedMessage<LoggerSimple::LogMemoryUsageRequest>& _msg);
+ static void LogMemoryUsageResponse(const ::fidl::DecodedMessage<LoggerSimple::LogMemoryUsageResponse>& _msg);
+ static void StartTimerRequest(const ::fidl::DecodedMessage<LoggerSimple::StartTimerRequest>& _msg);
+ static void StartTimerResponse(const ::fidl::DecodedMessage<LoggerSimple::StartTimerResponse>& _msg);
+ static void EndTimerRequest(const ::fidl::DecodedMessage<LoggerSimple::EndTimerRequest>& _msg);
+ static void EndTimerResponse(const ::fidl::DecodedMessage<LoggerSimple::EndTimerResponse>& _msg);
+ static void LogIntHistogramRequest(const ::fidl::DecodedMessage<LoggerSimple::LogIntHistogramRequest>& _msg);
+ static void LogIntHistogramResponse(const ::fidl::DecodedMessage<LoggerSimple::LogIntHistogramResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ProjectProfileTable;
+
+struct ProjectProfile {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ProjectProfileTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::mem::Buffer config = {};
+
+ ::llcpp::fuchsia::cobalt::ReleaseStage release_stage = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerFromProjectIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerFromProjectIdResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleFromProjectIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleFromProjectIdResponseTable;
+
+class LoggerFactory final {
+ LoggerFactory() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.cobalt.LoggerFactory";
+
+ struct CreateLoggerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerFactoryCreateLoggerResponseTable;
+ 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 CreateLoggerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::ProjectProfile profile;
+ ::zx::channel logger;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerFactoryCreateLoggerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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 = CreateLoggerResponse;
+ };
+
+ struct CreateLoggerSimpleResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleResponseTable;
+ 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 CreateLoggerSimpleRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::ProjectProfile profile;
+ ::zx::channel logger;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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 = CreateLoggerSimpleResponse;
+ };
+
+ struct CreateLoggerFromProjectIdResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerFactoryCreateLoggerFromProjectIdResponseTable;
+ 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 CreateLoggerFromProjectIdRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t project_id;
+ ::zx::channel logger;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerFactoryCreateLoggerFromProjectIdRequestTable;
+ 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 = CreateLoggerFromProjectIdResponse;
+ };
+
+ struct CreateLoggerSimpleFromProjectIdResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleFromProjectIdResponseTable;
+ 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 CreateLoggerSimpleFromProjectIdRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t project_id;
+ ::zx::channel logger;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerFactoryCreateLoggerSimpleFromProjectIdRequestTable;
+ 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 = CreateLoggerSimpleFromProjectIdResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class CreateLogger_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CreateLogger_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger);
+ ~CreateLogger_Impl() = default;
+ CreateLogger_Impl(CreateLogger_Impl&& other) = default;
+ CreateLogger_Impl& operator=(CreateLogger_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 CreateLoggerSimple_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CreateLoggerSimple_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger);
+ ~CreateLoggerSimple_Impl() = default;
+ CreateLoggerSimple_Impl(CreateLoggerSimple_Impl&& other) = default;
+ CreateLoggerSimple_Impl& operator=(CreateLoggerSimple_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 CreateLoggerFromProjectId_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CreateLoggerFromProjectId_Impl(::zx::unowned_channel _client_end, uint32_t project_id, ::zx::channel logger);
+ ~CreateLoggerFromProjectId_Impl() = default;
+ CreateLoggerFromProjectId_Impl(CreateLoggerFromProjectId_Impl&& other) = default;
+ CreateLoggerFromProjectId_Impl& operator=(CreateLoggerFromProjectId_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 CreateLoggerSimpleFromProjectId_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CreateLoggerSimpleFromProjectId_Impl(::zx::unowned_channel _client_end, uint32_t project_id, ::zx::channel logger);
+ ~CreateLoggerSimpleFromProjectId_Impl() = default;
+ CreateLoggerSimpleFromProjectId_Impl(CreateLoggerSimpleFromProjectId_Impl&& other) = default;
+ CreateLoggerSimpleFromProjectId_Impl& operator=(CreateLoggerSimpleFromProjectId_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 CreateLogger = CreateLogger_Impl<CreateLoggerResponse>;
+ using CreateLoggerSimple = CreateLoggerSimple_Impl<CreateLoggerSimpleResponse>;
+ using CreateLoggerFromProjectId = CreateLoggerFromProjectId_Impl<CreateLoggerFromProjectIdResponse>;
+ using CreateLoggerSimpleFromProjectId = CreateLoggerSimpleFromProjectId_Impl<CreateLoggerSimpleFromProjectIdResponse>;
+ };
+
+ // 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 CreateLogger_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CreateLogger_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+ ~CreateLogger_Impl() = default;
+ CreateLogger_Impl(CreateLogger_Impl&& other) = default;
+ CreateLogger_Impl& operator=(CreateLogger_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 CreateLoggerSimple_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CreateLoggerSimple_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+ ~CreateLoggerSimple_Impl() = default;
+ CreateLoggerSimple_Impl(CreateLoggerSimple_Impl&& other) = default;
+ CreateLoggerSimple_Impl& operator=(CreateLoggerSimple_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 CreateLoggerFromProjectId_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CreateLoggerFromProjectId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+ ~CreateLoggerFromProjectId_Impl() = default;
+ CreateLoggerFromProjectId_Impl(CreateLoggerFromProjectId_Impl&& other) = default;
+ CreateLoggerFromProjectId_Impl& operator=(CreateLoggerFromProjectId_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 CreateLoggerSimpleFromProjectId_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CreateLoggerSimpleFromProjectId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+ ~CreateLoggerSimpleFromProjectId_Impl() = default;
+ CreateLoggerSimpleFromProjectId_Impl(CreateLoggerSimpleFromProjectId_Impl&& other) = default;
+ CreateLoggerSimpleFromProjectId_Impl& operator=(CreateLoggerSimpleFromProjectId_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 CreateLogger = CreateLogger_Impl<CreateLoggerResponse>;
+ using CreateLoggerSimple = CreateLoggerSimple_Impl<CreateLoggerSimpleResponse>;
+ using CreateLoggerFromProjectId = CreateLoggerFromProjectId_Impl<CreateLoggerFromProjectIdResponse>;
+ using CreateLoggerSimpleFromProjectId = CreateLoggerSimpleFromProjectId_Impl<CreateLoggerSimpleFromProjectIdResponse>;
+ };
+
+ 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::CreateLogger CreateLogger(::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateLogger CreateLogger(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateLoggerSimple CreateLoggerSimple(::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateLoggerSimple CreateLoggerSimple(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateLoggerFromProjectId CreateLoggerFromProjectId(uint32_t project_id, ::zx::channel logger);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateLoggerFromProjectId CreateLoggerFromProjectId(::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateLoggerSimpleFromProjectId CreateLoggerSimpleFromProjectId(uint32_t project_id, ::zx::channel logger);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateLoggerSimpleFromProjectId CreateLoggerSimpleFromProjectId(::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::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::CreateLogger CreateLogger(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateLogger CreateLogger(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateLoggerSimple CreateLoggerSimple(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateLoggerSimple CreateLoggerSimple(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateLoggerFromProjectId CreateLoggerFromProjectId(::zx::unowned_channel _client_end, uint32_t project_id, ::zx::channel logger);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateLoggerFromProjectId CreateLoggerFromProjectId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateLoggerSimpleFromProjectId CreateLoggerSimpleFromProjectId(::zx::unowned_channel _client_end, uint32_t project_id, ::zx::channel logger);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateLoggerSimpleFromProjectId CreateLoggerSimpleFromProjectId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t project_id, ::zx::channel logger, ::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<CreateLoggerResponse> CreateLogger(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateLoggerRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<CreateLoggerSimpleResponse> CreateLoggerSimple(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateLoggerSimpleRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<CreateLoggerFromProjectIdResponse> CreateLoggerFromProjectId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateLoggerFromProjectIdRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<CreateLoggerSimpleFromProjectIdResponse> CreateLoggerSimpleFromProjectId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = LoggerFactory;
+ using _Base = ::fidl::CompleterBase;
+
+ class CreateLoggerCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<CreateLoggerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CreateLoggerCompleter = ::fidl::Completer<CreateLoggerCompleterBase>;
+
+ virtual void CreateLogger(::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, CreateLoggerCompleter::Sync _completer) = 0;
+
+ class CreateLoggerSimpleCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<CreateLoggerSimpleResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CreateLoggerSimpleCompleter = ::fidl::Completer<CreateLoggerSimpleCompleterBase>;
+
+ virtual void CreateLoggerSimple(::llcpp::fuchsia::cobalt::ProjectProfile profile, ::zx::channel logger, CreateLoggerSimpleCompleter::Sync _completer) = 0;
+
+ class CreateLoggerFromProjectIdCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<CreateLoggerFromProjectIdResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CreateLoggerFromProjectIdCompleter = ::fidl::Completer<CreateLoggerFromProjectIdCompleterBase>;
+
+ virtual void CreateLoggerFromProjectId(uint32_t project_id, ::zx::channel logger, CreateLoggerFromProjectIdCompleter::Sync _completer) = 0;
+
+ class CreateLoggerSimpleFromProjectIdCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<CreateLoggerSimpleFromProjectIdResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CreateLoggerSimpleFromProjectIdCompleter = ::fidl::Completer<CreateLoggerSimpleFromProjectIdCompleterBase>;
+
+ virtual void CreateLoggerSimpleFromProjectId(uint32_t project_id, ::zx::channel logger, CreateLoggerSimpleFromProjectIdCompleter::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 CreateLoggerRequest(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerRequest>& _msg);
+ static void CreateLoggerResponse(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerResponse>& _msg);
+ static void CreateLoggerSimpleRequest(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerSimpleRequest>& _msg);
+ static void CreateLoggerSimpleResponse(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerSimpleResponse>& _msg);
+ static void CreateLoggerFromProjectIdRequest(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerFromProjectIdRequest>& _msg);
+ static void CreateLoggerFromProjectIdResponse(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerFromProjectIdResponse>& _msg);
+ static void CreateLoggerSimpleFromProjectIdRequest(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerSimpleFromProjectIdRequest>& _msg);
+ static void CreateLoggerSimpleFromProjectIdResponse(const ::fidl::DecodedMessage<LoggerFactory::CreateLoggerSimpleFromProjectIdResponse>& _msg);
+ };
+};
+
+constexpr uint32_t MAX_TIMER_ID_LENGTH = 64u;
+
+constexpr uint32_t MAX_HISTOGRAM_BUCKETS = 500u;
+
+constexpr uint32_t MAX_EVENT_CODE_COUNT = 5u;
+
+constexpr uint32_t MAX_COMPONENT_LENGTH = 64u;
+
+constexpr uint32_t MAX_CHANNEL_NAME_LENGTH = 256u;
+
+constexpr int64_t MAX_BYTES_PER_EVENT = 102400u;
+
+constexpr uint32_t MAX_BATCHED_EVENTS = 64u;
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_HistogramBucketTable;
+
+struct HistogramBucket {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_HistogramBucketTable;
+ 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;
+
+ uint32_t index = {};
+
+ uint64_t count = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_ExperimentTable;
+
+// SystemProfileUpdater Interface
+struct Experiment {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_ExperimentTable;
+ 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;
+
+ uint64_t experiment_id = {};
+
+ uint32_t arm_id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_SystemDataUpdaterSetExperimentStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_SystemDataUpdaterSetExperimentStateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_SystemDataUpdaterSetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_SystemDataUpdaterSetChannelResponseTable;
+
+class SystemDataUpdater final {
+ SystemDataUpdater() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.cobalt.SystemDataUpdater";
+
+ struct SetExperimentStateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_SystemDataUpdaterSetExperimentStateResponseTable;
+ 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 SetExperimentStateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_SystemDataUpdaterSetExperimentStateRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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 = SetExperimentStateResponse;
+ };
+
+ struct SetChannelResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_SystemDataUpdaterSetChannelResponseTable;
+ 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 SetChannelRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView current_channel;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_SystemDataUpdaterSetChannelRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 256;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 256;
+ 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 = SetChannelResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class SetExperimentState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetExperimentState_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments);
+ ~SetExperimentState_Impl() = default;
+ SetExperimentState_Impl(SetExperimentState_Impl&& other) = default;
+ SetExperimentState_Impl& operator=(SetExperimentState_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 SetChannel_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::StringView current_channel);
+ ~SetChannel_Impl() = default;
+ SetChannel_Impl(SetChannel_Impl&& other) = default;
+ SetChannel_Impl& operator=(SetChannel_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 SetExperimentState = SetExperimentState_Impl<SetExperimentStateResponse>;
+ using SetChannel = SetChannel_Impl<SetChannelResponse>;
+ };
+
+ // 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 SetExperimentState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetExperimentState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments, ::fidl::BytePart _response_buffer);
+ ~SetExperimentState_Impl() = default;
+ SetExperimentState_Impl(SetExperimentState_Impl&& other) = default;
+ SetExperimentState_Impl& operator=(SetExperimentState_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 SetChannel_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView current_channel, ::fidl::BytePart _response_buffer);
+ ~SetChannel_Impl() = default;
+ SetChannel_Impl(SetChannel_Impl&& other) = default;
+ SetChannel_Impl& operator=(SetChannel_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 SetExperimentState = SetExperimentState_Impl<SetExperimentStateResponse>;
+ using SetChannel = SetChannel_Impl<SetChannelResponse>;
+ };
+
+ 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 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SetExperimentState SetExperimentState(::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetExperimentState SetExperimentState(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments, ::fidl::BytePart _response_buffer);
+
+ // Allocates 312 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetChannel SetChannel(::fidl::StringView current_channel);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetChannel SetChannel(::fidl::BytePart _request_buffer, ::fidl::StringView current_channel, ::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 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SetExperimentState SetExperimentState(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetExperimentState SetExperimentState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments, ::fidl::BytePart _response_buffer);
+
+ // Allocates 312 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetChannel SetChannel(::zx::unowned_channel _client_end, ::fidl::StringView current_channel);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetChannel SetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView current_channel, ::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<SetExperimentStateResponse> SetExperimentState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetExperimentStateRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<SetChannelResponse> SetChannel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetChannelRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = SystemDataUpdater;
+ using _Base = ::fidl::CompleterBase;
+
+ class SetExperimentStateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<SetExperimentStateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetExperimentStateCompleter = ::fidl::Completer<SetExperimentStateCompleterBase>;
+
+ virtual void SetExperimentState(::fidl::VectorView<::llcpp::fuchsia::cobalt::Experiment> experiments, SetExperimentStateCompleter::Sync _completer) = 0;
+
+ class SetChannelCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<SetChannelResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetChannelCompleter = ::fidl::Completer<SetChannelCompleterBase>;
+
+ virtual void SetChannel(::fidl::StringView current_channel, SetChannelCompleter::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 SetExperimentStateRequest(const ::fidl::DecodedMessage<SystemDataUpdater::SetExperimentStateRequest>& _msg);
+ static void SetExperimentStateResponse(const ::fidl::DecodedMessage<SystemDataUpdater::SetExperimentStateResponse>& _msg);
+ static void SetChannelRequest(const ::fidl::DecodedMessage<SystemDataUpdater::SetChannelRequest>& _msg);
+ static void SetChannelResponse(const ::fidl::DecodedMessage<SystemDataUpdater::SetChannelResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_EventTable;
+
+struct Event {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_EventTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_CountEventTable;
+
+struct CountEvent {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_CountEventTable;
+ 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;
+
+ int64_t period_duration_micros = {};
+
+ int64_t count = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_CobaltEventTable;
+
+struct CobaltEvent {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_CobaltEventTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 64;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8104;
+ static constexpr bool HasPointer = true;
+
+ uint32_t metric_id = {};
+
+ ::fidl::VectorView<uint32_t> event_codes = {};
+
+ ::fidl::StringView component = {};
+
+ ::llcpp::fuchsia::cobalt::EventPayload payload = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogEventCountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogEventCountResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogElapsedTimeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogElapsedTimeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogFrameRateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogFrameRateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogMemoryUsageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogMemoryUsageResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerStartTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerStartTimerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerEndTimerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerEndTimerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogIntHistogramRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogIntHistogramResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCustomEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCustomEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCobaltEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCobaltEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCobaltEventsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_cobalt_LoggerLogCobaltEventsResponseTable;
+
+class Logger final {
+ Logger() = delete;
+ public:
+
+ struct LogEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogEventResponseTable;
+ 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 LogEventRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogEventRequestTable;
+ 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 = LogEventResponse;
+ };
+
+ struct LogEventCountResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogEventCountResponseTable;
+ 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 LogEventCountRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t period_duration_micros;
+ int64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogEventCountRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogEventCountResponse;
+ };
+
+ struct LogElapsedTimeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogElapsedTimeResponseTable;
+ 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 LogElapsedTimeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t elapsed_micros;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogElapsedTimeRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogElapsedTimeResponse;
+ };
+
+ struct LogFrameRateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogFrameRateResponseTable;
+ 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 LogFrameRateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ float fps;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogFrameRateRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogFrameRateResponse;
+ };
+
+ struct LogMemoryUsageResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogMemoryUsageResponseTable;
+ 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 LogMemoryUsageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ int64_t bytes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogMemoryUsageRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = LogMemoryUsageResponse;
+ };
+
+ struct StartTimerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerStartTimerResponseTable;
+ 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 StartTimerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ ::fidl::StringView timer_id;
+ uint64_t timestamp;
+ uint32_t timeout_s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerStartTimerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 72;
+ static constexpr uint32_t MaxOutOfLine = 128;
+ static constexpr uint32_t AltPrimarySize = 72;
+ 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 = StartTimerResponse;
+ };
+
+ struct EndTimerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerEndTimerResponseTable;
+ 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 EndTimerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView timer_id;
+ uint64_t timestamp;
+ uint32_t timeout_s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerEndTimerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 64;
+ 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 = EndTimerResponse;
+ };
+
+ struct LogIntHistogramResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogIntHistogramResponseTable;
+ 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 LogIntHistogramRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ uint32_t event_code;
+ ::fidl::StringView component;
+ ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogIntHistogramRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 8064;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 8064;
+ 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 = LogIntHistogramResponse;
+ };
+
+ struct LogCustomEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogCustomEventResponseTable;
+ 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 LogCustomEventRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t metric_id;
+ ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogCustomEventRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = LogCustomEventResponse;
+ };
+
+ struct LogCobaltEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogCobaltEventResponseTable;
+ 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 LogCobaltEventRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::CobaltEvent event;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogCobaltEventRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 8104;
+ static constexpr uint32_t AltPrimarySize = 80;
+ static constexpr uint32_t AltMaxOutOfLine = 8104;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = LogCobaltEventResponse;
+ };
+
+ struct LogCobaltEventsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::cobalt::Status status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogCobaltEventsResponseTable;
+ 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 LogCobaltEventsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_cobalt_LoggerLogCobaltEventsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 522752;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 522752;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = LogCobaltEventsResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class LogEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogEvent_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code);
+ ~LogEvent_Impl() = default;
+ LogEvent_Impl(LogEvent_Impl&& other) = default;
+ LogEvent_Impl& operator=(LogEvent_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 LogEventCount_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogEventCount_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+ ~LogEventCount_Impl() = default;
+ LogEventCount_Impl(LogEventCount_Impl&& other) = default;
+ LogEventCount_Impl& operator=(LogEventCount_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 LogElapsedTime_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogElapsedTime_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+ ~LogElapsedTime_Impl() = default;
+ LogElapsedTime_Impl(LogElapsedTime_Impl&& other) = default;
+ LogElapsedTime_Impl& operator=(LogElapsedTime_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 LogFrameRate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogFrameRate_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+ ~LogFrameRate_Impl() = default;
+ LogFrameRate_Impl(LogFrameRate_Impl&& other) = default;
+ LogFrameRate_Impl& operator=(LogFrameRate_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 LogMemoryUsage_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogMemoryUsage_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+ ~LogMemoryUsage_Impl() = default;
+ LogMemoryUsage_Impl(LogMemoryUsage_Impl&& other) = default;
+ LogMemoryUsage_Impl& operator=(LogMemoryUsage_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 StartTimer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ StartTimer_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+ ~StartTimer_Impl() = default;
+ StartTimer_Impl(StartTimer_Impl&& other) = default;
+ StartTimer_Impl& operator=(StartTimer_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 EndTimer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+ ~EndTimer_Impl() = default;
+ EndTimer_Impl(EndTimer_Impl&& other) = default;
+ EndTimer_Impl& operator=(EndTimer_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 LogIntHistogram_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogIntHistogram_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram);
+ ~LogIntHistogram_Impl() = default;
+ LogIntHistogram_Impl(LogIntHistogram_Impl&& other) = default;
+ LogIntHistogram_Impl& operator=(LogIntHistogram_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 LogCustomEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogCustomEvent_Impl(::zx::unowned_channel _client_end, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values);
+ ~LogCustomEvent_Impl() = default;
+ LogCustomEvent_Impl(LogCustomEvent_Impl&& other) = default;
+ LogCustomEvent_Impl& operator=(LogCustomEvent_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 LogCobaltEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogCobaltEvent_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::CobaltEvent event);
+ ~LogCobaltEvent_Impl() = default;
+ LogCobaltEvent_Impl(LogCobaltEvent_Impl&& other) = default;
+ LogCobaltEvent_Impl& operator=(LogCobaltEvent_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 LogCobaltEvents_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LogCobaltEvents_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events);
+ ~LogCobaltEvents_Impl() = default;
+ LogCobaltEvents_Impl(LogCobaltEvents_Impl&& other) = default;
+ LogCobaltEvents_Impl& operator=(LogCobaltEvents_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 LogEvent = LogEvent_Impl<LogEventResponse>;
+ using LogEventCount = LogEventCount_Impl<LogEventCountResponse>;
+ using LogElapsedTime = LogElapsedTime_Impl<LogElapsedTimeResponse>;
+ using LogFrameRate = LogFrameRate_Impl<LogFrameRateResponse>;
+ using LogMemoryUsage = LogMemoryUsage_Impl<LogMemoryUsageResponse>;
+ using StartTimer = StartTimer_Impl<StartTimerResponse>;
+ using EndTimer = EndTimer_Impl<EndTimerResponse>;
+ using LogIntHistogram = LogIntHistogram_Impl<LogIntHistogramResponse>;
+ using LogCustomEvent = LogCustomEvent_Impl<LogCustomEventResponse>;
+ using LogCobaltEvent = LogCobaltEvent_Impl<LogCobaltEventResponse>;
+ using LogCobaltEvents = LogCobaltEvents_Impl<LogCobaltEventsResponse>;
+ };
+
+ // 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 LogEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+ ~LogEvent_Impl() = default;
+ LogEvent_Impl(LogEvent_Impl&& other) = default;
+ LogEvent_Impl& operator=(LogEvent_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 LogEventCount_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogEventCount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+ ~LogEventCount_Impl() = default;
+ LogEventCount_Impl(LogEventCount_Impl&& other) = default;
+ LogEventCount_Impl& operator=(LogEventCount_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 LogElapsedTime_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogElapsedTime_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+ ~LogElapsedTime_Impl() = default;
+ LogElapsedTime_Impl(LogElapsedTime_Impl&& other) = default;
+ LogElapsedTime_Impl& operator=(LogElapsedTime_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 LogFrameRate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogFrameRate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+ ~LogFrameRate_Impl() = default;
+ LogFrameRate_Impl(LogFrameRate_Impl&& other) = default;
+ LogFrameRate_Impl& operator=(LogFrameRate_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 LogMemoryUsage_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogMemoryUsage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+ ~LogMemoryUsage_Impl() = default;
+ LogMemoryUsage_Impl(LogMemoryUsage_Impl&& other) = default;
+ LogMemoryUsage_Impl& operator=(LogMemoryUsage_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 StartTimer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ StartTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+ ~StartTimer_Impl() = default;
+ StartTimer_Impl(StartTimer_Impl&& other) = default;
+ StartTimer_Impl& operator=(StartTimer_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 EndTimer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ EndTimer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+ ~EndTimer_Impl() = default;
+ EndTimer_Impl(EndTimer_Impl&& other) = default;
+ EndTimer_Impl& operator=(EndTimer_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 LogIntHistogram_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogIntHistogram_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram, ::fidl::BytePart _response_buffer);
+ ~LogIntHistogram_Impl() = default;
+ LogIntHistogram_Impl(LogIntHistogram_Impl&& other) = default;
+ LogIntHistogram_Impl& operator=(LogIntHistogram_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 LogCustomEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogCustomEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values, ::fidl::BytePart _response_buffer);
+ ~LogCustomEvent_Impl() = default;
+ LogCustomEvent_Impl(LogCustomEvent_Impl&& other) = default;
+ LogCustomEvent_Impl& operator=(LogCustomEvent_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 LogCobaltEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogCobaltEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::CobaltEvent event, ::fidl::BytePart _response_buffer);
+ ~LogCobaltEvent_Impl() = default;
+ LogCobaltEvent_Impl(LogCobaltEvent_Impl&& other) = default;
+ LogCobaltEvent_Impl& operator=(LogCobaltEvent_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 LogCobaltEvents_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LogCobaltEvents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events, ::fidl::BytePart _response_buffer);
+ ~LogCobaltEvents_Impl() = default;
+ LogCobaltEvents_Impl(LogCobaltEvents_Impl&& other) = default;
+ LogCobaltEvents_Impl& operator=(LogCobaltEvents_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 LogEvent = LogEvent_Impl<LogEventResponse>;
+ using LogEventCount = LogEventCount_Impl<LogEventCountResponse>;
+ using LogElapsedTime = LogElapsedTime_Impl<LogElapsedTimeResponse>;
+ using LogFrameRate = LogFrameRate_Impl<LogFrameRateResponse>;
+ using LogMemoryUsage = LogMemoryUsage_Impl<LogMemoryUsageResponse>;
+ using StartTimer = StartTimer_Impl<StartTimerResponse>;
+ using EndTimer = EndTimer_Impl<EndTimerResponse>;
+ using LogIntHistogram = LogIntHistogram_Impl<LogIntHistogramResponse>;
+ using LogCustomEvent = LogCustomEvent_Impl<LogCustomEventResponse>;
+ using LogCobaltEvent = LogCobaltEvent_Impl<LogCobaltEventResponse>;
+ using LogCobaltEvents = LogCobaltEvents_Impl<LogCobaltEventsResponse>;
+ };
+
+ 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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogEvent LogEvent(uint32_t metric_id, uint32_t event_code);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogEvent LogEvent(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogEventCount LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogEventCount LogEventCount(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogElapsedTime LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogElapsedTime LogElapsedTime(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogFrameRate LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogFrameRate LogFrameRate(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LogMemoryUsage LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogMemoryUsage LogMemoryUsage(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+
+ // Allocates 224 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::StartTimer StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::StartTimer StartTimer(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::EndTimer EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::EndTimer EndTimer(::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::LogIntHistogram LogIntHistogram(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogIntHistogram LogIntHistogram(::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::LogCustomEvent LogCustomEvent(uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogCustomEvent LogCustomEvent(::fidl::BytePart _request_buffer, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::LogCobaltEvent LogCobaltEvent(::llcpp::fuchsia::cobalt::CobaltEvent event);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogCobaltEvent LogCobaltEvent(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::CobaltEvent event, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::LogCobaltEvents LogCobaltEvents(::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LogCobaltEvents LogCobaltEvents(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events, ::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 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogEvent LogEvent(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogEvent LogEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::BytePart _response_buffer);
+
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogEventCount LogEventCount(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogEventCount LogEventCount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogElapsedTime LogElapsedTime(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogElapsedTime LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogFrameRate LogFrameRate(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogFrameRate LogFrameRate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LogMemoryUsage LogMemoryUsage(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogMemoryUsage LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, ::fidl::BytePart _response_buffer);
+
+ // Allocates 224 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::StartTimer StartTimer(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::StartTimer StartTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 136 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::EndTimer EndTimer(::zx::unowned_channel _client_end, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::EndTimer EndTimer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::LogIntHistogram LogIntHistogram(::zx::unowned_channel _client_end, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogIntHistogram LogIntHistogram(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::LogCustomEvent LogCustomEvent(::zx::unowned_channel _client_end, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogCustomEvent LogCustomEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::LogCobaltEvent LogCobaltEvent(::zx::unowned_channel _client_end, ::llcpp::fuchsia::cobalt::CobaltEvent event);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogCobaltEvent LogCobaltEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::cobalt::CobaltEvent event, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::LogCobaltEvents LogCobaltEvents(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LogCobaltEvents LogCobaltEvents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events, ::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<LogEventResponse> LogEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogEventCountResponse> LogEventCount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogEventCountRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogElapsedTimeResponse> LogElapsedTime(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogElapsedTimeRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogFrameRateResponse> LogFrameRate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogFrameRateRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogMemoryUsageResponse> LogMemoryUsage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogMemoryUsageRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<StartTimerResponse> StartTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StartTimerRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<EndTimerResponse> EndTimer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EndTimerRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogIntHistogramResponse> LogIntHistogram(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogIntHistogramRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogCustomEventResponse> LogCustomEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogCustomEventRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogCobaltEventResponse> LogCobaltEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogCobaltEventRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<LogCobaltEventsResponse> LogCobaltEvents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LogCobaltEventsRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Logger;
+ using _Base = ::fidl::CompleterBase;
+
+ class LogEventCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogEventCompleter = ::fidl::Completer<LogEventCompleterBase>;
+
+ virtual void LogEvent(uint32_t metric_id, uint32_t event_code, LogEventCompleter::Sync _completer) = 0;
+
+ class LogEventCountCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogEventCountResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogEventCountCompleter = ::fidl::Completer<LogEventCountCompleterBase>;
+
+ virtual void LogEventCount(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t period_duration_micros, int64_t count, LogEventCountCompleter::Sync _completer) = 0;
+
+ class LogElapsedTimeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogElapsedTimeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogElapsedTimeCompleter = ::fidl::Completer<LogElapsedTimeCompleterBase>;
+
+ virtual void LogElapsedTime(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t elapsed_micros, LogElapsedTimeCompleter::Sync _completer) = 0;
+
+ class LogFrameRateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogFrameRateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogFrameRateCompleter = ::fidl::Completer<LogFrameRateCompleterBase>;
+
+ virtual void LogFrameRate(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, float fps, LogFrameRateCompleter::Sync _completer) = 0;
+
+ class LogMemoryUsageCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogMemoryUsageResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogMemoryUsageCompleter = ::fidl::Completer<LogMemoryUsageCompleterBase>;
+
+ virtual void LogMemoryUsage(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, int64_t bytes, LogMemoryUsageCompleter::Sync _completer) = 0;
+
+ class StartTimerCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<StartTimerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StartTimerCompleter = ::fidl::Completer<StartTimerCompleterBase>;
+
+ virtual void StartTimer(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, StartTimerCompleter::Sync _completer) = 0;
+
+ class EndTimerCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<EndTimerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using EndTimerCompleter = ::fidl::Completer<EndTimerCompleterBase>;
+
+ virtual void EndTimer(::fidl::StringView timer_id, uint64_t timestamp, uint32_t timeout_s, EndTimerCompleter::Sync _completer) = 0;
+
+ class LogIntHistogramCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogIntHistogramResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogIntHistogramCompleter = ::fidl::Completer<LogIntHistogramCompleterBase>;
+
+ virtual void LogIntHistogram(uint32_t metric_id, uint32_t event_code, ::fidl::StringView component, ::fidl::VectorView<::llcpp::fuchsia::cobalt::HistogramBucket> histogram, LogIntHistogramCompleter::Sync _completer) = 0;
+
+ class LogCustomEventCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogCustomEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogCustomEventCompleter = ::fidl::Completer<LogCustomEventCompleterBase>;
+
+ virtual void LogCustomEvent(uint32_t metric_id, ::fidl::VectorView<::llcpp::fuchsia::cobalt::CustomEventValue> event_values, LogCustomEventCompleter::Sync _completer) = 0;
+
+ class LogCobaltEventCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogCobaltEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogCobaltEventCompleter = ::fidl::Completer<LogCobaltEventCompleterBase>;
+
+ virtual void LogCobaltEvent(::llcpp::fuchsia::cobalt::CobaltEvent event, LogCobaltEventCompleter::Sync _completer) = 0;
+
+ class LogCobaltEventsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::cobalt::Status status);
+ void Reply(::fidl::DecodedMessage<LogCobaltEventsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LogCobaltEventsCompleter = ::fidl::Completer<LogCobaltEventsCompleterBase>;
+
+ virtual void LogCobaltEvents(::fidl::VectorView<::llcpp::fuchsia::cobalt::CobaltEvent> events, LogCobaltEventsCompleter::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 LogEventRequest(const ::fidl::DecodedMessage<Logger::LogEventRequest>& _msg);
+ static void LogEventResponse(const ::fidl::DecodedMessage<Logger::LogEventResponse>& _msg);
+ static void LogEventCountRequest(const ::fidl::DecodedMessage<Logger::LogEventCountRequest>& _msg);
+ static void LogEventCountResponse(const ::fidl::DecodedMessage<Logger::LogEventCountResponse>& _msg);
+ static void LogElapsedTimeRequest(const ::fidl::DecodedMessage<Logger::LogElapsedTimeRequest>& _msg);
+ static void LogElapsedTimeResponse(const ::fidl::DecodedMessage<Logger::LogElapsedTimeResponse>& _msg);
+ static void LogFrameRateRequest(const ::fidl::DecodedMessage<Logger::LogFrameRateRequest>& _msg);
+ static void LogFrameRateResponse(const ::fidl::DecodedMessage<Logger::LogFrameRateResponse>& _msg);
+ static void LogMemoryUsageRequest(const ::fidl::DecodedMessage<Logger::LogMemoryUsageRequest>& _msg);
+ static void LogMemoryUsageResponse(const ::fidl::DecodedMessage<Logger::LogMemoryUsageResponse>& _msg);
+ static void StartTimerRequest(const ::fidl::DecodedMessage<Logger::StartTimerRequest>& _msg);
+ static void StartTimerResponse(const ::fidl::DecodedMessage<Logger::StartTimerResponse>& _msg);
+ static void EndTimerRequest(const ::fidl::DecodedMessage<Logger::EndTimerRequest>& _msg);
+ static void EndTimerResponse(const ::fidl::DecodedMessage<Logger::EndTimerResponse>& _msg);
+ static void LogIntHistogramRequest(const ::fidl::DecodedMessage<Logger::LogIntHistogramRequest>& _msg);
+ static void LogIntHistogramResponse(const ::fidl::DecodedMessage<Logger::LogIntHistogramResponse>& _msg);
+ static void LogCustomEventRequest(const ::fidl::DecodedMessage<Logger::LogCustomEventRequest>& _msg);
+ static void LogCustomEventResponse(const ::fidl::DecodedMessage<Logger::LogCustomEventResponse>& _msg);
+ static void LogCobaltEventRequest(const ::fidl::DecodedMessage<Logger::LogCobaltEventRequest>& _msg);
+ static void LogCobaltEventResponse(const ::fidl::DecodedMessage<Logger::LogCobaltEventResponse>& _msg);
+ static void LogCobaltEventsRequest(const ::fidl::DecodedMessage<Logger::LogCobaltEventsRequest>& _msg);
+ static void LogCobaltEventsResponse(const ::fidl::DecodedMessage<Logger::LogCobaltEventsResponse>& _msg);
+ };
+};
+
+} // namespace cobalt
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Value> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::Value>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::CustomEventValue> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::CustomEventValue>);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::CustomEventValue, dimension_name) == 0);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::CustomEventValue, value) == 16);
+static_assert(sizeof(::llcpp::fuchsia::cobalt::CustomEventValue) == ::llcpp::fuchsia::cobalt::CustomEventValue::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Controller::RequestSendSoonResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Controller::RequestSendSoonResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Controller::RequestSendSoonResponse)
+ == ::llcpp::fuchsia::cobalt::Controller::RequestSendSoonResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Controller::RequestSendSoonResponse, success) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Controller::BlockUntilEmptyRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Controller::BlockUntilEmptyRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Controller::BlockUntilEmptyRequest)
+ == ::llcpp::fuchsia::cobalt::Controller::BlockUntilEmptyRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Controller::BlockUntilEmptyRequest, max_wait_seconds) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Controller::GetNumSendAttemptsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Controller::GetNumSendAttemptsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Controller::GetNumSendAttemptsResponse)
+ == ::llcpp::fuchsia::cobalt::Controller::GetNumSendAttemptsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Controller::GetNumSendAttemptsResponse, num) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Controller::GetFailedSendAttemptsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Controller::GetFailedSendAttemptsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Controller::GetFailedSendAttemptsResponse)
+ == ::llcpp::fuchsia::cobalt::Controller::GetFailedSendAttemptsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Controller::GetFailedSendAttemptsResponse, num) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Controller::GetNumObservationsAddedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Controller::GetNumObservationsAddedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Controller::GetNumObservationsAddedResponse)
+ == ::llcpp::fuchsia::cobalt::Controller::GetNumObservationsAddedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Controller::GetNumObservationsAddedResponse, num_obs) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsRequest)
+ == ::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsRequest, day_index) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsRequest, report_ids) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsResponse)
+ == ::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Controller::GenerateAggregatedObservationsResponse, num_obs) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogEventRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogEventRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventRequest, event_code) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest, period_duration_micros) == 40);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountRequest, count) == 48);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogEventCountResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeRequest, elapsed_micros) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogElapsedTimeResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateRequest, fps) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogFrameRateResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageRequest, bytes) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::LogMemoryUsageResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest, timer_id) == 40);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest, timestamp) == 56);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerRequest, timeout_s) == 64);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::StartTimerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::StartTimerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::StartTimerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::StartTimerResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::EndTimerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::EndTimerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::EndTimerRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::EndTimerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::EndTimerRequest, timer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::EndTimerRequest, timestamp) == 32);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::EndTimerRequest, timeout_s) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerBase::EndTimerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerBase::EndTimerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerBase::EndTimerResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerBase::EndTimerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerBase::EndTimerResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogEventRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogEventRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventRequest, event_code) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest, period_duration_micros) == 40);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountRequest, count) == 48);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogEventCountResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeRequest, elapsed_micros) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogElapsedTimeResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateRequest, fps) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogFrameRateResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageRequest, bytes) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogMemoryUsageResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest, timer_id) == 40);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest, timestamp) == 56);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerRequest, timeout_s) == 64);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::StartTimerResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerRequest, timer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerRequest, timestamp) == 32);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerRequest, timeout_s) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::EndTimerResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest, bucket_indices) == 40);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramRequest, bucket_counts) == 56);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerSimple::LogIntHistogramResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::ProjectProfile> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::ProjectProfile>);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::ProjectProfile, config) == 0);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::ProjectProfile, release_stage) == 16);
+static_assert(sizeof(::llcpp::fuchsia::cobalt::ProjectProfile) == ::llcpp::fuchsia::cobalt::ProjectProfile::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerRequest, profile) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerRequest, logger) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleRequest, profile) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleRequest, logger) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdRequest, project_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdRequest, logger) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerFromProjectIdResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdRequest)
+ == ::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdRequest, project_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdRequest, logger) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdResponse)
+ == ::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::LoggerFactory::CreateLoggerSimpleFromProjectIdResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::HistogramBucket> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::HistogramBucket>);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::HistogramBucket, index) == 0);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::HistogramBucket, count) == 8);
+static_assert(sizeof(::llcpp::fuchsia::cobalt::HistogramBucket) == ::llcpp::fuchsia::cobalt::HistogramBucket::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Experiment> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::Experiment>);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Experiment, experiment_id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Experiment, arm_id) == 8);
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Experiment) == ::llcpp::fuchsia::cobalt::Experiment::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateRequest)
+ == ::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateRequest, experiments) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateResponse)
+ == ::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::SystemDataUpdater::SetExperimentStateResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelRequest)
+ == ::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelRequest, current_channel) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelResponse)
+ == ::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::SystemDataUpdater::SetChannelResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Event> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::Event>);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Event, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Event) == ::llcpp::fuchsia::cobalt::Event::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::CountEvent> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::CountEvent>);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::CountEvent, period_duration_micros) == 0);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::CountEvent, count) == 8);
+static_assert(sizeof(::llcpp::fuchsia::cobalt::CountEvent) == ::llcpp::fuchsia::cobalt::CountEvent::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::EventPayload> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::EventPayload>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::CobaltEvent> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::cobalt::CobaltEvent>);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::CobaltEvent, metric_id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::CobaltEvent, event_codes) == 8);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::CobaltEvent, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::CobaltEvent, payload) == 40);
+static_assert(sizeof(::llcpp::fuchsia::cobalt::CobaltEvent) == ::llcpp::fuchsia::cobalt::CobaltEvent::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogEventRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogEventRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogEventRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventRequest, event_code) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogEventResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest, period_duration_micros) == 40);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventCountRequest, count) == 48);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogEventCountResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogEventCountResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogEventCountResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogEventCountResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogEventCountResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeRequest, elapsed_micros) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogElapsedTimeResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogFrameRateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogFrameRateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogFrameRateRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogFrameRateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogFrameRateRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogFrameRateRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogFrameRateRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogFrameRateRequest, fps) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogFrameRateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogFrameRateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogFrameRateResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogFrameRateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogFrameRateResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageRequest, bytes) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogMemoryUsageResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::StartTimerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::StartTimerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::StartTimerRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::StartTimerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::StartTimerRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::StartTimerRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::StartTimerRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::StartTimerRequest, timer_id) == 40);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::StartTimerRequest, timestamp) == 56);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::StartTimerRequest, timeout_s) == 64);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::StartTimerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::StartTimerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::StartTimerResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::StartTimerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::StartTimerResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::EndTimerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::EndTimerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::EndTimerRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::EndTimerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::EndTimerRequest, timer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::EndTimerRequest, timestamp) == 32);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::EndTimerRequest, timeout_s) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::EndTimerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::EndTimerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::EndTimerResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::EndTimerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::EndTimerResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogIntHistogramRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogIntHistogramRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogIntHistogramRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogIntHistogramRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogIntHistogramRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogIntHistogramRequest, event_code) == 20);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogIntHistogramRequest, component) == 24);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogIntHistogramRequest, histogram) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogIntHistogramResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogIntHistogramResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogIntHistogramResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogIntHistogramResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogIntHistogramResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogCustomEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogCustomEventRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogCustomEventRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogCustomEventRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogCustomEventRequest, metric_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogCustomEventRequest, event_values) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogCustomEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogCustomEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogCustomEventResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogCustomEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogCustomEventResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogCobaltEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogCobaltEventRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogCobaltEventRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogCobaltEventRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogCobaltEventRequest, event) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogCobaltEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogCobaltEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogCobaltEventResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogCobaltEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogCobaltEventResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsRequest)
+ == ::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsRequest, events) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsResponse)
+ == ::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::cobalt::Logger::LogCobaltEventsResponse, status) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-debugdata/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-debugdata/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..f68d356
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-debugdata/gen/llcpp/fidl.cc
@@ -0,0 +1,273 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/debugdata/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace debugdata {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDebugData_Publish_Ordinal = 0x233ab68f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebugData_Publish_GenOrdinal = 0x32e10c8a45d9312alu;
+extern "C" const fidl_type_t v1_fuchsia_debugdata_DebugDataPublishRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_debugdata_DebugDataPublishResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebugData_LoadConfig_Ordinal = 0x934ade500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebugData_LoadConfig_GenOrdinal = 0x51012dfe3d37bdf6lu;
+extern "C" const fidl_type_t v1_fuchsia_debugdata_DebugDataLoadConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_debugdata_DebugDataLoadConfigResponseTable;
+
+} // namespace
+
+DebugData::ResultOf::Publish_Impl::Publish_Impl(::zx::unowned_channel _client_end, ::fidl::StringView data_sink, ::zx::vmo data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PublishRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ PublishRequest _request = {};
+ _request.data_sink = std::move(data_sink);
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<PublishRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DebugData::InPlace::Publish(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DebugData::ResultOf::Publish DebugData::SyncClient::Publish(::fidl::StringView data_sink, ::zx::vmo data) {
+ return ResultOf::Publish(::zx::unowned_channel(this->channel_), std::move(data_sink), std::move(data));
+}
+
+DebugData::ResultOf::Publish DebugData::Call::Publish(::zx::unowned_channel _client_end, ::fidl::StringView data_sink, ::zx::vmo data) {
+ return ResultOf::Publish(std::move(_client_end), std::move(data_sink), std::move(data));
+}
+
+
+DebugData::UnownedResultOf::Publish_Impl::Publish_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView data_sink, ::zx::vmo data) {
+ if (_request_buffer.capacity() < PublishRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ PublishRequest _request = {};
+ _request.data_sink = std::move(data_sink);
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<PublishRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DebugData::InPlace::Publish(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DebugData::UnownedResultOf::Publish DebugData::SyncClient::Publish(::fidl::BytePart _request_buffer, ::fidl::StringView data_sink, ::zx::vmo data) {
+ return UnownedResultOf::Publish(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data_sink), std::move(data));
+}
+
+DebugData::UnownedResultOf::Publish DebugData::Call::Publish(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView data_sink, ::zx::vmo data) {
+ return UnownedResultOf::Publish(std::move(_client_end), std::move(_request_buffer), std::move(data_sink), std::move(data));
+}
+
+::fidl::internal::StatusAndError DebugData::InPlace::Publish(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PublishRequest> params) {
+ DebugData::SetTransactionHeaderFor::PublishRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+DebugData::ResultOf::LoadConfig_Impl<DebugData::LoadConfigResponse>::LoadConfig_Impl(::zx::unowned_channel _client_end, ::fidl::StringView config_name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LoadConfigRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LoadConfigRequest _request = {};
+ _request.config_name = std::move(config_name);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LoadConfigRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DebugData::InPlace::LoadConfig(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DebugData::ResultOf::LoadConfig DebugData::SyncClient::LoadConfig(::fidl::StringView config_name) {
+ return ResultOf::LoadConfig(::zx::unowned_channel(this->channel_), std::move(config_name));
+}
+
+DebugData::ResultOf::LoadConfig DebugData::Call::LoadConfig(::zx::unowned_channel _client_end, ::fidl::StringView config_name) {
+ return ResultOf::LoadConfig(std::move(_client_end), std::move(config_name));
+}
+
+template <>
+DebugData::UnownedResultOf::LoadConfig_Impl<DebugData::LoadConfigResponse>::LoadConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView config_name, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LoadConfigRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LoadConfigResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LoadConfigRequest _request = {};
+ _request.config_name = std::move(config_name);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LoadConfigRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DebugData::InPlace::LoadConfig(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DebugData::UnownedResultOf::LoadConfig DebugData::SyncClient::LoadConfig(::fidl::BytePart _request_buffer, ::fidl::StringView config_name, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LoadConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config_name), std::move(_response_buffer));
+}
+
+DebugData::UnownedResultOf::LoadConfig DebugData::Call::LoadConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView config_name, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LoadConfig(std::move(_client_end), std::move(_request_buffer), std::move(config_name), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DebugData::LoadConfigResponse> DebugData::InPlace::LoadConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LoadConfigRequest> params, ::fidl::BytePart response_buffer) {
+ DebugData::SetTransactionHeaderFor::LoadConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugData::LoadConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LoadConfigRequest, LoadConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugData::LoadConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DebugData::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDebugData_Publish_Ordinal:
+ case kDebugData_Publish_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<PublishRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Publish(std::move(message->data_sink), std::move(message->data),
+ Interface::PublishCompleter::Sync(txn));
+ return true;
+ }
+ case kDebugData_LoadConfig_Ordinal:
+ case kDebugData_LoadConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LoadConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LoadConfig(std::move(message->config_name),
+ Interface::LoadConfigCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DebugData::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DebugData::Interface::LoadConfigCompleterBase::Reply(::zx::vmo config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LoadConfigResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LoadConfigResponse*>(_write_bytes);
+ DebugData::SetTransactionHeaderFor::LoadConfigResponse(
+ ::fidl::DecodedMessage<LoadConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LoadConfigResponse::PrimarySize,
+ LoadConfigResponse::PrimarySize)));
+ _response.config = std::move(config);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LoadConfigResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LoadConfigResponse>(std::move(_response_bytes)));
+}
+
+void DebugData::Interface::LoadConfigCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo config) {
+ if (_buffer.capacity() < LoadConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LoadConfigResponse*>(_buffer.data());
+ DebugData::SetTransactionHeaderFor::LoadConfigResponse(
+ ::fidl::DecodedMessage<LoadConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LoadConfigResponse::PrimarySize,
+ LoadConfigResponse::PrimarySize)));
+ _response.config = std::move(config);
+ _buffer.set_actual(sizeof(LoadConfigResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LoadConfigResponse>(std::move(_buffer)));
+}
+
+void DebugData::Interface::LoadConfigCompleterBase::Reply(::fidl::DecodedMessage<LoadConfigResponse> params) {
+ DebugData::SetTransactionHeaderFor::LoadConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DebugData::SetTransactionHeaderFor::PublishRequest(const ::fidl::DecodedMessage<DebugData::PublishRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugData_Publish_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DebugData::SetTransactionHeaderFor::LoadConfigRequest(const ::fidl::DecodedMessage<DebugData::LoadConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugData_LoadConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DebugData::SetTransactionHeaderFor::LoadConfigResponse(const ::fidl::DecodedMessage<DebugData::LoadConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugData_LoadConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace debugdata
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-debugdata/gen/llcpp/include/fuchsia/debugdata/llcpp/fidl.h b/zircon/system/fidl/fuchsia-debugdata/gen/llcpp/include/fuchsia/debugdata/llcpp/fidl.h
new file mode 100644
index 0000000..b51e3b5
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-debugdata/gen/llcpp/include/fuchsia/debugdata/llcpp/fidl.h
@@ -0,0 +1,372 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace debugdata {
+
+class DebugData;
+
+extern "C" const fidl_type_t v1_fuchsia_debugdata_DebugDataPublishRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_debugdata_DebugDataPublishResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_debugdata_DebugDataLoadConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_debugdata_DebugDataLoadConfigResponseTable;
+
+// DebugData defines the interface for instrumentation configuration and data publishing.
+class DebugData final {
+ DebugData() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.debugdata.DebugData";
+
+ struct PublishRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView data_sink;
+ ::zx::vmo data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_debugdata_DebugDataPublishRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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;
+ };
+
+ struct LoadConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_debugdata_DebugDataLoadConfigResponseTable;
+ 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;
+ };
+ struct LoadConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView config_name;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_debugdata_DebugDataLoadConfigRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = LoadConfigResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Publish_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Publish_Impl(::zx::unowned_channel _client_end, ::fidl::StringView data_sink, ::zx::vmo data);
+ ~Publish_Impl() = default;
+ Publish_Impl(Publish_Impl&& other) = default;
+ Publish_Impl& operator=(Publish_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class LoadConfig_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LoadConfig_Impl(::zx::unowned_channel _client_end, ::fidl::StringView config_name);
+ ~LoadConfig_Impl() = default;
+ LoadConfig_Impl(LoadConfig_Impl&& other) = default;
+ LoadConfig_Impl& operator=(LoadConfig_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 Publish = Publish_Impl;
+ using LoadConfig = LoadConfig_Impl<LoadConfigResponse>;
+ };
+
+ // 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:
+ class Publish_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Publish_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView data_sink, ::zx::vmo data);
+ ~Publish_Impl() = default;
+ Publish_Impl(Publish_Impl&& other) = default;
+ Publish_Impl& operator=(Publish_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class LoadConfig_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LoadConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView config_name, ::fidl::BytePart _response_buffer);
+ ~LoadConfig_Impl() = default;
+ LoadConfig_Impl(LoadConfig_Impl&& other) = default;
+ LoadConfig_Impl& operator=(LoadConfig_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 Publish = Publish_Impl;
+ using LoadConfig = LoadConfig_Impl<LoadConfigResponse>;
+ };
+
+ 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_; }
+
+ // The program runtime sends a string naming a `data_sink` and transfers the sole handle to
+ // a VMO containing the `data` it wants published there. The `data_sink` string identifies
+ // a type of data, and the VMO's object name can specifically identify the data set in this
+ // VMO. The client must transfer the only handle to the VMO (which prevents the VMO being
+ // resized without the receiver's knowledge), but it might still have the VMO mapped in and
+ // continue to write data to it. Code instrumentation runtimes use this to deliver large
+ // binary trace results.
+ // Request is heap-allocated.
+ ResultOf::Publish Publish(::fidl::StringView data_sink, ::zx::vmo data);
+
+ // The program runtime sends a string naming a `data_sink` and transfers the sole handle to
+ // a VMO containing the `data` it wants published there. The `data_sink` string identifies
+ // a type of data, and the VMO's object name can specifically identify the data set in this
+ // VMO. The client must transfer the only handle to the VMO (which prevents the VMO being
+ // resized without the receiver's knowledge), but it might still have the VMO mapped in and
+ // continue to write data to it. Code instrumentation runtimes use this to deliver large
+ // binary trace results.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Publish Publish(::fidl::BytePart _request_buffer, ::fidl::StringView data_sink, ::zx::vmo data);
+
+ // The program runtime names a `config_name` referring to a debug configuration of some kind
+ // and gets back a VMO to read configuration data from. The sanitizer runtimes use this to
+ // allow large options text to be stored in a file rather than passed directly in environment
+ // strings.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::LoadConfig LoadConfig(::fidl::StringView config_name);
+
+ // The program runtime names a `config_name` referring to a debug configuration of some kind
+ // and gets back a VMO to read configuration data from. The sanitizer runtimes use this to
+ // allow large options text to be stored in a file rather than passed directly in environment
+ // strings.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LoadConfig LoadConfig(::fidl::BytePart _request_buffer, ::fidl::StringView config_name, ::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:
+
+ // The program runtime sends a string naming a `data_sink` and transfers the sole handle to
+ // a VMO containing the `data` it wants published there. The `data_sink` string identifies
+ // a type of data, and the VMO's object name can specifically identify the data set in this
+ // VMO. The client must transfer the only handle to the VMO (which prevents the VMO being
+ // resized without the receiver's knowledge), but it might still have the VMO mapped in and
+ // continue to write data to it. Code instrumentation runtimes use this to deliver large
+ // binary trace results.
+ // Request is heap-allocated.
+ static ResultOf::Publish Publish(::zx::unowned_channel _client_end, ::fidl::StringView data_sink, ::zx::vmo data);
+
+ // The program runtime sends a string naming a `data_sink` and transfers the sole handle to
+ // a VMO containing the `data` it wants published there. The `data_sink` string identifies
+ // a type of data, and the VMO's object name can specifically identify the data set in this
+ // VMO. The client must transfer the only handle to the VMO (which prevents the VMO being
+ // resized without the receiver's knowledge), but it might still have the VMO mapped in and
+ // continue to write data to it. Code instrumentation runtimes use this to deliver large
+ // binary trace results.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Publish Publish(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView data_sink, ::zx::vmo data);
+
+ // The program runtime names a `config_name` referring to a debug configuration of some kind
+ // and gets back a VMO to read configuration data from. The sanitizer runtimes use this to
+ // allow large options text to be stored in a file rather than passed directly in environment
+ // strings.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::LoadConfig LoadConfig(::zx::unowned_channel _client_end, ::fidl::StringView config_name);
+
+ // The program runtime names a `config_name` referring to a debug configuration of some kind
+ // and gets back a VMO to read configuration data from. The sanitizer runtimes use this to
+ // allow large options text to be stored in a file rather than passed directly in environment
+ // strings.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LoadConfig LoadConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView config_name, ::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:
+
+ // The program runtime sends a string naming a `data_sink` and transfers the sole handle to
+ // a VMO containing the `data` it wants published there. The `data_sink` string identifies
+ // a type of data, and the VMO's object name can specifically identify the data set in this
+ // VMO. The client must transfer the only handle to the VMO (which prevents the VMO being
+ // resized without the receiver's knowledge), but it might still have the VMO mapped in and
+ // continue to write data to it. Code instrumentation runtimes use this to deliver large
+ // binary trace results.
+ static ::fidl::internal::StatusAndError Publish(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PublishRequest> params);
+
+ // The program runtime names a `config_name` referring to a debug configuration of some kind
+ // and gets back a VMO to read configuration data from. The sanitizer runtimes use this to
+ // allow large options text to be stored in a file rather than passed directly in environment
+ // strings.
+ static ::fidl::DecodeResult<LoadConfigResponse> LoadConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LoadConfigRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DebugData;
+ using _Base = ::fidl::CompleterBase;
+
+ using PublishCompleter = ::fidl::Completer<>;
+
+ virtual void Publish(::fidl::StringView data_sink, ::zx::vmo data, PublishCompleter::Sync _completer) = 0;
+
+ class LoadConfigCompleterBase : public _Base {
+ public:
+ void Reply(::zx::vmo config);
+ void Reply(::fidl::BytePart _buffer, ::zx::vmo config);
+ void Reply(::fidl::DecodedMessage<LoadConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LoadConfigCompleter = ::fidl::Completer<LoadConfigCompleterBase>;
+
+ virtual void LoadConfig(::fidl::StringView config_name, LoadConfigCompleter::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 PublishRequest(const ::fidl::DecodedMessage<DebugData::PublishRequest>& _msg);
+ static void LoadConfigRequest(const ::fidl::DecodedMessage<DebugData::LoadConfigRequest>& _msg);
+ static void LoadConfigResponse(const ::fidl::DecodedMessage<DebugData::LoadConfigResponse>& _msg);
+ };
+};
+
+// The maximum length, in bytes, of data sink or configuration name.
+constexpr uint64_t MAX_NAME = 1024u;
+
+} // namespace debugdata
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::debugdata::DebugData::PublishRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::debugdata::DebugData::PublishRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::debugdata::DebugData::PublishRequest)
+ == ::llcpp::fuchsia::debugdata::DebugData::PublishRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::debugdata::DebugData::PublishRequest, data_sink) == 16);
+static_assert(offsetof(::llcpp::fuchsia::debugdata::DebugData::PublishRequest, data) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::debugdata::DebugData::LoadConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::debugdata::DebugData::LoadConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::debugdata::DebugData::LoadConfigRequest)
+ == ::llcpp::fuchsia::debugdata::DebugData::LoadConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::debugdata::DebugData::LoadConfigRequest, config_name) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::debugdata::DebugData::LoadConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::debugdata::DebugData::LoadConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::debugdata::DebugData::LoadConfigResponse)
+ == ::llcpp::fuchsia::debugdata::DebugData::LoadConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::debugdata::DebugData::LoadConfigResponse, config) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-device-manager/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-device-manager/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..e07e5ff
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-device-manager/gen/llcpp/fidl.cc
@@ -0,0 +1,4278 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/device/manager/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace manager {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDebugDumper_DumpTree_Ordinal = 0x3804588c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebugDumper_DumpTree_GenOrdinal = 0x2985d961d4cd5c04lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpTreeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpTreeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebugDumper_DumpDrivers_Ordinal = 0x5237dc7300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebugDumper_DumpDrivers_GenOrdinal = 0x1cbb832b151a378lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpDriversRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpDriversResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebugDumper_DumpBindingProperties_Ordinal = 0x1954f6f100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebugDumper_DumpBindingProperties_GenOrdinal = 0x15b8794479ed66edlu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesResponseTable;
+
+} // namespace
+template <>
+DebugDumper::ResultOf::DumpTree_Impl<DebugDumper::DumpTreeResponse>::DumpTree_Impl(::zx::unowned_channel _client_end, ::zx::vmo output) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpTreeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DumpTreeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DumpTreeRequest*>(_write_bytes);
+ _request.output = std::move(output);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpTreeRequest));
+ ::fidl::DecodedMessage<DumpTreeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DebugDumper::InPlace::DumpTree(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DebugDumper::ResultOf::DumpTree DebugDumper::SyncClient::DumpTree(::zx::vmo output) {
+ return ResultOf::DumpTree(::zx::unowned_channel(this->channel_), std::move(output));
+}
+
+DebugDumper::ResultOf::DumpTree DebugDumper::Call::DumpTree(::zx::unowned_channel _client_end, ::zx::vmo output) {
+ return ResultOf::DumpTree(std::move(_client_end), std::move(output));
+}
+
+template <>
+DebugDumper::UnownedResultOf::DumpTree_Impl<DebugDumper::DumpTreeResponse>::DumpTree_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DumpTreeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DumpTreeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DumpTreeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DumpTreeRequest*>(_request_buffer.data());
+ _request.output = std::move(output);
+ _request_buffer.set_actual(sizeof(DumpTreeRequest));
+ ::fidl::DecodedMessage<DumpTreeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DebugDumper::InPlace::DumpTree(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DebugDumper::UnownedResultOf::DumpTree DebugDumper::SyncClient::DumpTree(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DumpTree(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
+}
+
+DebugDumper::UnownedResultOf::DumpTree DebugDumper::Call::DumpTree(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DumpTree(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DebugDumper::DumpTreeResponse> DebugDumper::InPlace::DumpTree(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpTreeRequest> params, ::fidl::BytePart response_buffer) {
+ DebugDumper::SetTransactionHeaderFor::DumpTreeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugDumper::DumpTreeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DumpTreeRequest, DumpTreeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugDumper::DumpTreeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DebugDumper::ResultOf::DumpDrivers_Impl<DebugDumper::DumpDriversResponse>::DumpDrivers_Impl(::zx::unowned_channel _client_end, ::zx::vmo output) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpDriversRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DumpDriversRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DumpDriversRequest*>(_write_bytes);
+ _request.output = std::move(output);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpDriversRequest));
+ ::fidl::DecodedMessage<DumpDriversRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DebugDumper::InPlace::DumpDrivers(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DebugDumper::ResultOf::DumpDrivers DebugDumper::SyncClient::DumpDrivers(::zx::vmo output) {
+ return ResultOf::DumpDrivers(::zx::unowned_channel(this->channel_), std::move(output));
+}
+
+DebugDumper::ResultOf::DumpDrivers DebugDumper::Call::DumpDrivers(::zx::unowned_channel _client_end, ::zx::vmo output) {
+ return ResultOf::DumpDrivers(std::move(_client_end), std::move(output));
+}
+
+template <>
+DebugDumper::UnownedResultOf::DumpDrivers_Impl<DebugDumper::DumpDriversResponse>::DumpDrivers_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DumpDriversRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DumpDriversResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DumpDriversRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DumpDriversRequest*>(_request_buffer.data());
+ _request.output = std::move(output);
+ _request_buffer.set_actual(sizeof(DumpDriversRequest));
+ ::fidl::DecodedMessage<DumpDriversRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DebugDumper::InPlace::DumpDrivers(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DebugDumper::UnownedResultOf::DumpDrivers DebugDumper::SyncClient::DumpDrivers(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DumpDrivers(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
+}
+
+DebugDumper::UnownedResultOf::DumpDrivers DebugDumper::Call::DumpDrivers(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DumpDrivers(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DebugDumper::DumpDriversResponse> DebugDumper::InPlace::DumpDrivers(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpDriversRequest> params, ::fidl::BytePart response_buffer) {
+ DebugDumper::SetTransactionHeaderFor::DumpDriversRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugDumper::DumpDriversResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DumpDriversRequest, DumpDriversResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugDumper::DumpDriversResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DebugDumper::ResultOf::DumpBindingProperties_Impl<DebugDumper::DumpBindingPropertiesResponse>::DumpBindingProperties_Impl(::zx::unowned_channel _client_end, ::zx::vmo output) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpBindingPropertiesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DumpBindingPropertiesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DumpBindingPropertiesRequest*>(_write_bytes);
+ _request.output = std::move(output);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpBindingPropertiesRequest));
+ ::fidl::DecodedMessage<DumpBindingPropertiesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DebugDumper::InPlace::DumpBindingProperties(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DebugDumper::ResultOf::DumpBindingProperties DebugDumper::SyncClient::DumpBindingProperties(::zx::vmo output) {
+ return ResultOf::DumpBindingProperties(::zx::unowned_channel(this->channel_), std::move(output));
+}
+
+DebugDumper::ResultOf::DumpBindingProperties DebugDumper::Call::DumpBindingProperties(::zx::unowned_channel _client_end, ::zx::vmo output) {
+ return ResultOf::DumpBindingProperties(std::move(_client_end), std::move(output));
+}
+
+template <>
+DebugDumper::UnownedResultOf::DumpBindingProperties_Impl<DebugDumper::DumpBindingPropertiesResponse>::DumpBindingProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DumpBindingPropertiesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DumpBindingPropertiesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DumpBindingPropertiesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DumpBindingPropertiesRequest*>(_request_buffer.data());
+ _request.output = std::move(output);
+ _request_buffer.set_actual(sizeof(DumpBindingPropertiesRequest));
+ ::fidl::DecodedMessage<DumpBindingPropertiesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DebugDumper::InPlace::DumpBindingProperties(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DebugDumper::UnownedResultOf::DumpBindingProperties DebugDumper::SyncClient::DumpBindingProperties(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DumpBindingProperties(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
+}
+
+DebugDumper::UnownedResultOf::DumpBindingProperties DebugDumper::Call::DumpBindingProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DumpBindingProperties(std::move(_client_end), std::move(_request_buffer), std::move(output), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse> DebugDumper::InPlace::DumpBindingProperties(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpBindingPropertiesRequest> params, ::fidl::BytePart response_buffer) {
+ DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DumpBindingPropertiesRequest, DumpBindingPropertiesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugDumper::DumpBindingPropertiesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DebugDumper::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDebugDumper_DumpTree_Ordinal:
+ case kDebugDumper_DumpTree_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DumpTreeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->DumpTree(std::move(message->output),
+ Interface::DumpTreeCompleter::Sync(txn));
+ return true;
+ }
+ case kDebugDumper_DumpDrivers_Ordinal:
+ case kDebugDumper_DumpDrivers_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DumpDriversRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->DumpDrivers(std::move(message->output),
+ Interface::DumpDriversCompleter::Sync(txn));
+ return true;
+ }
+ case kDebugDumper_DumpBindingProperties_Ordinal:
+ case kDebugDumper_DumpBindingProperties_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DumpBindingPropertiesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->DumpBindingProperties(std::move(message->output),
+ Interface::DumpBindingPropertiesCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DebugDumper::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DebugDumper::Interface::DumpTreeCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpTreeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DumpTreeResponse*>(_write_bytes);
+ DebugDumper::SetTransactionHeaderFor::DumpTreeResponse(
+ ::fidl::DecodedMessage<DumpTreeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DumpTreeResponse::PrimarySize,
+ DumpTreeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.written = std::move(written);
+ _response.available = std::move(available);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpTreeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DumpTreeResponse>(std::move(_response_bytes)));
+}
+
+void DebugDumper::Interface::DumpTreeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) {
+ if (_buffer.capacity() < DumpTreeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DumpTreeResponse*>(_buffer.data());
+ DebugDumper::SetTransactionHeaderFor::DumpTreeResponse(
+ ::fidl::DecodedMessage<DumpTreeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DumpTreeResponse::PrimarySize,
+ DumpTreeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.written = std::move(written);
+ _response.available = std::move(available);
+ _buffer.set_actual(sizeof(DumpTreeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DumpTreeResponse>(std::move(_buffer)));
+}
+
+void DebugDumper::Interface::DumpTreeCompleterBase::Reply(::fidl::DecodedMessage<DumpTreeResponse> params) {
+ DebugDumper::SetTransactionHeaderFor::DumpTreeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DebugDumper::Interface::DumpDriversCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpDriversResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DumpDriversResponse*>(_write_bytes);
+ DebugDumper::SetTransactionHeaderFor::DumpDriversResponse(
+ ::fidl::DecodedMessage<DumpDriversResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DumpDriversResponse::PrimarySize,
+ DumpDriversResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.written = std::move(written);
+ _response.available = std::move(available);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpDriversResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DumpDriversResponse>(std::move(_response_bytes)));
+}
+
+void DebugDumper::Interface::DumpDriversCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) {
+ if (_buffer.capacity() < DumpDriversResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DumpDriversResponse*>(_buffer.data());
+ DebugDumper::SetTransactionHeaderFor::DumpDriversResponse(
+ ::fidl::DecodedMessage<DumpDriversResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DumpDriversResponse::PrimarySize,
+ DumpDriversResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.written = std::move(written);
+ _response.available = std::move(available);
+ _buffer.set_actual(sizeof(DumpDriversResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DumpDriversResponse>(std::move(_buffer)));
+}
+
+void DebugDumper::Interface::DumpDriversCompleterBase::Reply(::fidl::DecodedMessage<DumpDriversResponse> params) {
+ DebugDumper::SetTransactionHeaderFor::DumpDriversResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(int32_t status, uint64_t written, uint64_t available) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpBindingPropertiesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DumpBindingPropertiesResponse*>(_write_bytes);
+ DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesResponse(
+ ::fidl::DecodedMessage<DumpBindingPropertiesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DumpBindingPropertiesResponse::PrimarySize,
+ DumpBindingPropertiesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.written = std::move(written);
+ _response.available = std::move(available);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpBindingPropertiesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DumpBindingPropertiesResponse>(std::move(_response_bytes)));
+}
+
+void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available) {
+ if (_buffer.capacity() < DumpBindingPropertiesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DumpBindingPropertiesResponse*>(_buffer.data());
+ DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesResponse(
+ ::fidl::DecodedMessage<DumpBindingPropertiesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DumpBindingPropertiesResponse::PrimarySize,
+ DumpBindingPropertiesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.written = std::move(written);
+ _response.available = std::move(available);
+ _buffer.set_actual(sizeof(DumpBindingPropertiesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DumpBindingPropertiesResponse>(std::move(_buffer)));
+}
+
+void DebugDumper::Interface::DumpBindingPropertiesCompleterBase::Reply(::fidl::DecodedMessage<DumpBindingPropertiesResponse> params) {
+ DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DebugDumper::SetTransactionHeaderFor::DumpTreeRequest(const ::fidl::DecodedMessage<DebugDumper::DumpTreeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpTree_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DebugDumper::SetTransactionHeaderFor::DumpTreeResponse(const ::fidl::DecodedMessage<DebugDumper::DumpTreeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpTree_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DebugDumper::SetTransactionHeaderFor::DumpDriversRequest(const ::fidl::DecodedMessage<DebugDumper::DumpDriversRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpDrivers_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DebugDumper::SetTransactionHeaderFor::DumpDriversResponse(const ::fidl::DecodedMessage<DebugDumper::DumpDriversResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpDrivers_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesRequest(const ::fidl::DecodedMessage<DebugDumper::DumpBindingPropertiesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpBindingProperties_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DebugDumper::SetTransactionHeaderFor::DumpBindingPropertiesResponse(const ::fidl::DecodedMessage<DebugDumper::DumpBindingPropertiesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugDumper_DumpBindingProperties_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kAdministrator_Suspend_Ordinal = 0x7ecaa18c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kAdministrator_Suspend_GenOrdinal = 0x4bb44c32133da26elu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_AdministratorSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_AdministratorSuspendResponseTable;
+
+} // namespace
+template <>
+Administrator::ResultOf::Suspend_Impl<Administrator::SuspendResponse>::Suspend_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendRequest));
+ ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Administrator::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Administrator::ResultOf::Suspend Administrator::SyncClient::Suspend(uint32_t flags) {
+ return ResultOf::Suspend(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Administrator::ResultOf::Suspend Administrator::Call::Suspend(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::Suspend(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Administrator::UnownedResultOf::Suspend_Impl<Administrator::SuspendResponse>::Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SuspendRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(SuspendRequest));
+ ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Administrator::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Administrator::UnownedResultOf::Suspend Administrator::SyncClient::Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Suspend(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Administrator::UnownedResultOf::Suspend Administrator::Call::Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Suspend(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Administrator::SuspendResponse> Administrator::InPlace::Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer) {
+ Administrator::SetTransactionHeaderFor::SuspendRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Administrator::SuspendResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SuspendRequest, SuspendResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Administrator::SuspendResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Administrator::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kAdministrator_Suspend_Ordinal:
+ case kAdministrator_Suspend_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SuspendRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Suspend(std::move(message->flags),
+ Interface::SuspendCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Administrator::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Administrator::Interface::SuspendCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SuspendResponse*>(_write_bytes);
+ Administrator::SetTransactionHeaderFor::SuspendResponse(
+ ::fidl::DecodedMessage<SuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendResponse::PrimarySize,
+ SuspendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_response_bytes)));
+}
+
+void Administrator::Interface::SuspendCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SuspendResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SuspendResponse*>(_buffer.data());
+ Administrator::SetTransactionHeaderFor::SuspendResponse(
+ ::fidl::DecodedMessage<SuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendResponse::PrimarySize,
+ SuspendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SuspendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_buffer)));
+}
+
+void Administrator::Interface::SuspendCompleterBase::Reply(::fidl::DecodedMessage<SuspendResponse> params) {
+ Administrator::SetTransactionHeaderFor::SuspendResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Administrator::SetTransactionHeaderFor::SuspendRequest(const ::fidl::DecodedMessage<Administrator::SuspendRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAdministrator_Suspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Administrator::SetTransactionHeaderFor::SuspendResponse(const ::fidl::DecodedMessage<Administrator::SuspendResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAdministrator_Suspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevhostController_CreateDeviceStub_Ordinal = 0x2d8e104b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevhostController_CreateDeviceStub_GenOrdinal = 0x62409c9e94ff9699lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevhostController_CreateDevice_Ordinal = 0x2f6f95b700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevhostController_CreateDevice_GenOrdinal = 0x7dbabaee2c92e2c6lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevhostController_CreateCompositeDevice_Ordinal = 0x358e5a0900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevhostController_CreateCompositeDevice_GenOrdinal = 0x1d0ddbfd4f798c80lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceResponseTable;
+
+} // namespace
+
+DevhostController::ResultOf::CreateDeviceStub_Impl::CreateDeviceStub_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateDeviceStubRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CreateDeviceStubRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateDeviceStubRequest*>(_write_bytes);
+ _request.coordinator_rpc = std::move(coordinator_rpc);
+ _request.device_controller_rpc = std::move(device_controller_rpc);
+ _request.protocol_id = std::move(protocol_id);
+ _request.local_device_id = std::move(local_device_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateDeviceStubRequest));
+ ::fidl::DecodedMessage<CreateDeviceStubRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DevhostController::InPlace::CreateDeviceStub(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DevhostController::ResultOf::CreateDeviceStub DevhostController::SyncClient::CreateDeviceStub(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) {
+ return ResultOf::CreateDeviceStub(::zx::unowned_channel(this->channel_), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(protocol_id), std::move(local_device_id));
+}
+
+DevhostController::ResultOf::CreateDeviceStub DevhostController::Call::CreateDeviceStub(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) {
+ return ResultOf::CreateDeviceStub(std::move(_client_end), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(protocol_id), std::move(local_device_id));
+}
+
+
+DevhostController::UnownedResultOf::CreateDeviceStub_Impl::CreateDeviceStub_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) {
+ if (_request_buffer.capacity() < CreateDeviceStubRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CreateDeviceStubRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateDeviceStubRequest*>(_request_buffer.data());
+ _request.coordinator_rpc = std::move(coordinator_rpc);
+ _request.device_controller_rpc = std::move(device_controller_rpc);
+ _request.protocol_id = std::move(protocol_id);
+ _request.local_device_id = std::move(local_device_id);
+ _request_buffer.set_actual(sizeof(CreateDeviceStubRequest));
+ ::fidl::DecodedMessage<CreateDeviceStubRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DevhostController::InPlace::CreateDeviceStub(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DevhostController::UnownedResultOf::CreateDeviceStub DevhostController::SyncClient::CreateDeviceStub(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) {
+ return UnownedResultOf::CreateDeviceStub(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(protocol_id), std::move(local_device_id));
+}
+
+DevhostController::UnownedResultOf::CreateDeviceStub DevhostController::Call::CreateDeviceStub(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id) {
+ return UnownedResultOf::CreateDeviceStub(std::move(_client_end), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(protocol_id), std::move(local_device_id));
+}
+
+::fidl::internal::StatusAndError DevhostController::InPlace::CreateDeviceStub(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceStubRequest> params) {
+ DevhostController::SetTransactionHeaderFor::CreateDeviceStubRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+DevhostController::ResultOf::CreateDevice_Impl::CreateDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateDeviceRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ CreateDeviceRequest _request = {};
+ _request.coordinator_rpc = std::move(coordinator_rpc);
+ _request.device_controller_rpc = std::move(device_controller_rpc);
+ _request.driver_path = std::move(driver_path);
+ _request.driver = std::move(driver);
+ _request.parent_proxy = std::move(parent_proxy);
+ _request.proxy_args = std::move(proxy_args);
+ _request.local_device_id = std::move(local_device_id);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CreateDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DevhostController::InPlace::CreateDevice(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DevhostController::ResultOf::CreateDevice DevhostController::SyncClient::CreateDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
+ return ResultOf::CreateDevice(::zx::unowned_channel(this->channel_), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id));
+}
+
+DevhostController::ResultOf::CreateDevice DevhostController::Call::CreateDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
+ return ResultOf::CreateDevice(std::move(_client_end), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id));
+}
+
+
+DevhostController::UnownedResultOf::CreateDevice_Impl::CreateDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
+ if (_request_buffer.capacity() < CreateDeviceRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ CreateDeviceRequest _request = {};
+ _request.coordinator_rpc = std::move(coordinator_rpc);
+ _request.device_controller_rpc = std::move(device_controller_rpc);
+ _request.driver_path = std::move(driver_path);
+ _request.driver = std::move(driver);
+ _request.parent_proxy = std::move(parent_proxy);
+ _request.proxy_args = std::move(proxy_args);
+ _request.local_device_id = std::move(local_device_id);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CreateDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DevhostController::InPlace::CreateDevice(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DevhostController::UnownedResultOf::CreateDevice DevhostController::SyncClient::CreateDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
+ return UnownedResultOf::CreateDevice(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id));
+}
+
+DevhostController::UnownedResultOf::CreateDevice DevhostController::Call::CreateDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id) {
+ return UnownedResultOf::CreateDevice(std::move(_client_end), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(driver_path), std::move(driver), std::move(parent_proxy), std::move(proxy_args), std::move(local_device_id));
+}
+
+::fidl::internal::StatusAndError DevhostController::InPlace::CreateDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceRequest> params) {
+ DevhostController::SetTransactionHeaderFor::CreateDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+DevhostController::ResultOf::CreateCompositeDevice_Impl<DevhostController::CreateCompositeDeviceResponse>::CreateCompositeDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateCompositeDeviceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ CreateCompositeDeviceRequest _request = {};
+ _request.coordinator_rpc = std::move(coordinator_rpc);
+ _request.device_controller_rpc = std::move(device_controller_rpc);
+ _request.components = std::move(components);
+ _request.name = std::move(name);
+ _request.local_device_id = std::move(local_device_id);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CreateCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DevhostController::InPlace::CreateCompositeDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DevhostController::ResultOf::CreateCompositeDevice DevhostController::SyncClient::CreateCompositeDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) {
+ return ResultOf::CreateCompositeDevice(::zx::unowned_channel(this->channel_), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(components), std::move(name), std::move(local_device_id));
+}
+
+DevhostController::ResultOf::CreateCompositeDevice DevhostController::Call::CreateCompositeDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id) {
+ return ResultOf::CreateCompositeDevice(std::move(_client_end), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(components), std::move(name), std::move(local_device_id));
+}
+
+template <>
+DevhostController::UnownedResultOf::CreateCompositeDevice_Impl<DevhostController::CreateCompositeDeviceResponse>::CreateCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CreateCompositeDeviceRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CreateCompositeDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ CreateCompositeDeviceRequest _request = {};
+ _request.coordinator_rpc = std::move(coordinator_rpc);
+ _request.device_controller_rpc = std::move(device_controller_rpc);
+ _request.components = std::move(components);
+ _request.name = std::move(name);
+ _request.local_device_id = std::move(local_device_id);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CreateCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DevhostController::InPlace::CreateCompositeDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DevhostController::UnownedResultOf::CreateCompositeDevice DevhostController::SyncClient::CreateCompositeDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateCompositeDevice(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(components), std::move(name), std::move(local_device_id), std::move(_response_buffer));
+}
+
+DevhostController::UnownedResultOf::CreateCompositeDevice DevhostController::Call::CreateCompositeDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateCompositeDevice(std::move(_client_end), std::move(_request_buffer), std::move(coordinator_rpc), std::move(device_controller_rpc), std::move(components), std::move(name), std::move(local_device_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse> DevhostController::InPlace::CreateCompositeDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateCompositeDeviceRequest> params, ::fidl::BytePart response_buffer) {
+ DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CreateCompositeDeviceRequest, CreateCompositeDeviceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DevhostController::CreateCompositeDeviceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DevhostController::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevhostController_CreateDeviceStub_Ordinal:
+ case kDevhostController_CreateDeviceStub_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateDeviceStubRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateDeviceStub(std::move(message->coordinator_rpc), std::move(message->device_controller_rpc), std::move(message->protocol_id), std::move(message->local_device_id),
+ Interface::CreateDeviceStubCompleter::Sync(txn));
+ return true;
+ }
+ case kDevhostController_CreateDevice_Ordinal:
+ case kDevhostController_CreateDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateDevice(std::move(message->coordinator_rpc), std::move(message->device_controller_rpc), std::move(message->driver_path), std::move(message->driver), std::move(message->parent_proxy), std::move(message->proxy_args), std::move(message->local_device_id),
+ Interface::CreateDeviceCompleter::Sync(txn));
+ return true;
+ }
+ case kDevhostController_CreateCompositeDevice_Ordinal:
+ case kDevhostController_CreateCompositeDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateCompositeDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateCompositeDevice(std::move(message->coordinator_rpc), std::move(message->device_controller_rpc), std::move(message->components), std::move(message->name), std::move(message->local_device_id),
+ Interface::CreateCompositeDeviceCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DevhostController::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateCompositeDeviceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CreateCompositeDeviceResponse*>(_write_bytes);
+ DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceResponse(
+ ::fidl::DecodedMessage<CreateCompositeDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateCompositeDeviceResponse::PrimarySize,
+ CreateCompositeDeviceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateCompositeDeviceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateCompositeDeviceResponse>(std::move(_response_bytes)));
+}
+
+void DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < CreateCompositeDeviceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CreateCompositeDeviceResponse*>(_buffer.data());
+ DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceResponse(
+ ::fidl::DecodedMessage<CreateCompositeDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateCompositeDeviceResponse::PrimarySize,
+ CreateCompositeDeviceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CreateCompositeDeviceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateCompositeDeviceResponse>(std::move(_buffer)));
+}
+
+void DevhostController::Interface::CreateCompositeDeviceCompleterBase::Reply(::fidl::DecodedMessage<CreateCompositeDeviceResponse> params) {
+ DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DevhostController::SetTransactionHeaderFor::CreateDeviceStubRequest(const ::fidl::DecodedMessage<DevhostController::CreateDeviceStubRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevhostController_CreateDeviceStub_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DevhostController::SetTransactionHeaderFor::CreateDeviceRequest(const ::fidl::DecodedMessage<DevhostController::CreateDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevhostController_CreateDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceRequest(const ::fidl::DecodedMessage<DevhostController::CreateCompositeDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevhostController_CreateCompositeDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DevhostController::SetTransactionHeaderFor::CreateCompositeDeviceResponse(const ::fidl::DecodedMessage<DevhostController::CreateCompositeDeviceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevhostController_CreateCompositeDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_AddDevice_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_AddDevice_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_AddDevice_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_AddDeviceInvisible_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_AddDeviceInvisible_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_AddDeviceInvisible_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DeviceController_Unbind_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DeviceController_Unbind_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DeviceController_Unbind_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DeviceController_CompleteRemoval_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DeviceController_CompleteRemoval_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DeviceController_CompleteRemoval_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_RunCompatibilityTests_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_RunCompatibilityTests_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_RunCompatibilityTests_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_PublishMetadata_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_PublishMetadata_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_PublishMetadata_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_MakeVisible_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_MakeVisible_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_MakeVisible_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_LoadFirmware_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_LoadFirmware_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_LoadFirmware_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_GetTopologicalPath_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_GetTopologicalPath_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_GetTopologicalPath_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_GetMetadata_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_GetMetadata_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_GetMetadata_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_GetMetadataSize_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_GetMetadataSize_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_GetMetadataSize_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_DirectoryWatch_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_DirectoryWatch_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_DirectoryWatch_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_BindDevice_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_BindDevice_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_BindDevice_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_AddMetadata_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_AddMetadata_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_AddMetadata_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Coordinator_AddCompositeDevice_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Coordinator_AddCompositeDevice_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Coordinator_AddCompositeDevice_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_BindDriver_Ordinal = 0x3d3eea9b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_BindDriver_GenOrdinal = 0x1600a1d1d6024855lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerBindDriverRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerBindDriverResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_ConnectProxy_Ordinal = 0x582e0d9b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_ConnectProxy_GenOrdinal = 0x72206da90d1f3f2flu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerConnectProxyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerConnectProxyResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_Init_Ordinal = 0x35ec4e6200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_Init_GenOrdinal = 0x4443bcf5eb580b37lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerInitRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerInitResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_Unbind_Ordinal = 0x72bdd28200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_Unbind_GenOrdinal = 0x2d3f793e42cc3fd0lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerUnbindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerUnbindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_CompleteRemoval_Ordinal = 0x1554eba800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_CompleteRemoval_GenOrdinal = 0x25d6d94c85d60771lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteRemovalRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteRemovalResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_Suspend_Ordinal = 0x4490901a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_Suspend_GenOrdinal = 0x77bf98a1d5d4adbblu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerSuspendResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_Resume_Ordinal = 0x4d69ba3300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_Resume_GenOrdinal = 0x4f111286b7bd9caflu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerResumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerResumeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_CompleteCompatibilityTests_Ordinal = 0x475e367c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceController_CompleteCompatibilityTests_GenOrdinal = 0x3883342451945549lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsResponseTable;
+
+} // namespace
+template <>
+DeviceController::ResultOf::BindDriver_Impl<DeviceController::BindDriverResponse>::BindDriver_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDriverRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ BindDriverRequest _request = {};
+ _request.driver_path = std::move(driver_path);
+ _request.driver = std::move(driver);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindDriverRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DeviceController::InPlace::BindDriver(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DeviceController::ResultOf::BindDriver DeviceController::SyncClient::BindDriver(::fidl::StringView driver_path, ::zx::vmo driver) {
+ return ResultOf::BindDriver(::zx::unowned_channel(this->channel_), std::move(driver_path), std::move(driver));
+}
+
+DeviceController::ResultOf::BindDriver DeviceController::Call::BindDriver(::zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver) {
+ return ResultOf::BindDriver(std::move(_client_end), std::move(driver_path), std::move(driver));
+}
+
+template <>
+DeviceController::UnownedResultOf::BindDriver_Impl<DeviceController::BindDriverResponse>::BindDriver_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BindDriverRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BindDriverResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ BindDriverRequest _request = {};
+ _request.driver_path = std::move(driver_path);
+ _request.driver = std::move(driver);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindDriverRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DeviceController::InPlace::BindDriver(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DeviceController::UnownedResultOf::BindDriver DeviceController::SyncClient::BindDriver(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::BindDriver(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(driver_path), std::move(driver), std::move(_response_buffer));
+}
+
+DeviceController::UnownedResultOf::BindDriver DeviceController::Call::BindDriver(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::BindDriver(std::move(_client_end), std::move(_request_buffer), std::move(driver_path), std::move(driver), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DeviceController::BindDriverResponse> DeviceController::InPlace::BindDriver(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDriverRequest> params, ::fidl::BytePart response_buffer) {
+ DeviceController::SetTransactionHeaderFor::BindDriverRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::BindDriverResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BindDriverRequest, BindDriverResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::BindDriverResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+DeviceController::ResultOf::ConnectProxy_Impl::ConnectProxy_Impl(::zx::unowned_channel _client_end, ::zx::channel shadow) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectProxyRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConnectProxyRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConnectProxyRequest*>(_write_bytes);
+ _request.shadow = std::move(shadow);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConnectProxyRequest));
+ ::fidl::DecodedMessage<ConnectProxyRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DeviceController::InPlace::ConnectProxy(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceController::ResultOf::ConnectProxy DeviceController::SyncClient::ConnectProxy(::zx::channel shadow) {
+ return ResultOf::ConnectProxy(::zx::unowned_channel(this->channel_), std::move(shadow));
+}
+
+DeviceController::ResultOf::ConnectProxy DeviceController::Call::ConnectProxy(::zx::unowned_channel _client_end, ::zx::channel shadow) {
+ return ResultOf::ConnectProxy(std::move(_client_end), std::move(shadow));
+}
+
+
+DeviceController::UnownedResultOf::ConnectProxy_Impl::ConnectProxy_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow) {
+ if (_request_buffer.capacity() < ConnectProxyRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ConnectProxyRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConnectProxyRequest*>(_request_buffer.data());
+ _request.shadow = std::move(shadow);
+ _request_buffer.set_actual(sizeof(ConnectProxyRequest));
+ ::fidl::DecodedMessage<ConnectProxyRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DeviceController::InPlace::ConnectProxy(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceController::UnownedResultOf::ConnectProxy DeviceController::SyncClient::ConnectProxy(::fidl::BytePart _request_buffer, ::zx::channel shadow) {
+ return UnownedResultOf::ConnectProxy(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(shadow));
+}
+
+DeviceController::UnownedResultOf::ConnectProxy DeviceController::Call::ConnectProxy(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow) {
+ return UnownedResultOf::ConnectProxy(std::move(_client_end), std::move(_request_buffer), std::move(shadow));
+}
+
+::fidl::internal::StatusAndError DeviceController::InPlace::ConnectProxy(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectProxyRequest> params) {
+ DeviceController::SetTransactionHeaderFor::ConnectProxyRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+DeviceController::ResultOf::Init_Impl<DeviceController::InitResponse>::Init_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InitRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, InitRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(InitRequest));
+ ::fidl::DecodedMessage<InitRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DeviceController::InPlace::Init(std::move(_client_end), Super::response_buffer()));
+}
+
+DeviceController::ResultOf::Init DeviceController::SyncClient::Init() {
+ return ResultOf::Init(::zx::unowned_channel(this->channel_));
+}
+
+DeviceController::ResultOf::Init DeviceController::Call::Init(::zx::unowned_channel _client_end) {
+ return ResultOf::Init(std::move(_client_end));
+}
+
+template <>
+DeviceController::UnownedResultOf::Init_Impl<DeviceController::InitResponse>::Init_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(InitRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, InitRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(InitRequest));
+ ::fidl::DecodedMessage<InitRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DeviceController::InPlace::Init(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DeviceController::UnownedResultOf::Init DeviceController::SyncClient::Init(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Init(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DeviceController::UnownedResultOf::Init DeviceController::Call::Init(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Init(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DeviceController::InitResponse> DeviceController::InPlace::Init(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(InitRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<InitRequest> params(std::move(_request_buffer));
+ DeviceController::SetTransactionHeaderFor::InitRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::InitResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<InitRequest, InitResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::InitResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DeviceController::ResultOf::Unbind_Impl<DeviceController::UnbindResponse>::Unbind_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, UnbindRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnbindRequest));
+ ::fidl::DecodedMessage<UnbindRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DeviceController::InPlace::Unbind(std::move(_client_end), Super::response_buffer()));
+}
+
+DeviceController::ResultOf::Unbind DeviceController::SyncClient::Unbind() {
+ return ResultOf::Unbind(::zx::unowned_channel(this->channel_));
+}
+
+DeviceController::ResultOf::Unbind DeviceController::Call::Unbind(::zx::unowned_channel _client_end) {
+ return ResultOf::Unbind(std::move(_client_end));
+}
+
+template <>
+DeviceController::UnownedResultOf::Unbind_Impl<DeviceController::UnbindResponse>::Unbind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnbindRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, UnbindRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(UnbindRequest));
+ ::fidl::DecodedMessage<UnbindRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DeviceController::InPlace::Unbind(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DeviceController::UnownedResultOf::Unbind DeviceController::SyncClient::Unbind(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unbind(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DeviceController::UnownedResultOf::Unbind DeviceController::Call::Unbind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unbind(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DeviceController::UnbindResponse> DeviceController::InPlace::Unbind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(UnbindRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<UnbindRequest> params(std::move(_request_buffer));
+ DeviceController::SetTransactionHeaderFor::UnbindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::UnbindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnbindRequest, UnbindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::UnbindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DeviceController::ResultOf::CompleteRemoval_Impl<DeviceController::CompleteRemovalResponse>::CompleteRemoval_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CompleteRemovalRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CompleteRemovalRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CompleteRemovalRequest));
+ ::fidl::DecodedMessage<CompleteRemovalRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DeviceController::InPlace::CompleteRemoval(std::move(_client_end), Super::response_buffer()));
+}
+
+DeviceController::ResultOf::CompleteRemoval DeviceController::SyncClient::CompleteRemoval() {
+ return ResultOf::CompleteRemoval(::zx::unowned_channel(this->channel_));
+}
+
+DeviceController::ResultOf::CompleteRemoval DeviceController::Call::CompleteRemoval(::zx::unowned_channel _client_end) {
+ return ResultOf::CompleteRemoval(std::move(_client_end));
+}
+
+template <>
+DeviceController::UnownedResultOf::CompleteRemoval_Impl<DeviceController::CompleteRemovalResponse>::CompleteRemoval_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CompleteRemovalRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CompleteRemovalRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CompleteRemovalRequest));
+ ::fidl::DecodedMessage<CompleteRemovalRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DeviceController::InPlace::CompleteRemoval(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DeviceController::UnownedResultOf::CompleteRemoval DeviceController::SyncClient::CompleteRemoval(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CompleteRemoval(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DeviceController::UnownedResultOf::CompleteRemoval DeviceController::Call::CompleteRemoval(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CompleteRemoval(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DeviceController::CompleteRemovalResponse> DeviceController::InPlace::CompleteRemoval(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CompleteRemovalRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CompleteRemovalRequest> params(std::move(_request_buffer));
+ DeviceController::SetTransactionHeaderFor::CompleteRemovalRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::CompleteRemovalResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CompleteRemovalRequest, CompleteRemovalResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::CompleteRemovalResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DeviceController::ResultOf::Suspend_Impl<DeviceController::SuspendResponse>::Suspend_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendRequest));
+ ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DeviceController::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DeviceController::ResultOf::Suspend DeviceController::SyncClient::Suspend(uint32_t flags) {
+ return ResultOf::Suspend(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+DeviceController::ResultOf::Suspend DeviceController::Call::Suspend(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::Suspend(std::move(_client_end), std::move(flags));
+}
+
+template <>
+DeviceController::UnownedResultOf::Suspend_Impl<DeviceController::SuspendResponse>::Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SuspendRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(SuspendRequest));
+ ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DeviceController::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DeviceController::UnownedResultOf::Suspend DeviceController::SyncClient::Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Suspend(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+DeviceController::UnownedResultOf::Suspend DeviceController::Call::Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Suspend(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DeviceController::SuspendResponse> DeviceController::InPlace::Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer) {
+ DeviceController::SetTransactionHeaderFor::SuspendRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::SuspendResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SuspendRequest, SuspendResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::SuspendResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DeviceController::ResultOf::Resume_Impl<DeviceController::ResumeResponse>::Resume_Impl(::zx::unowned_channel _client_end, uint32_t target_system_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ResumeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ResumeRequest*>(_write_bytes);
+ _request.target_system_state = std::move(target_system_state);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeRequest));
+ ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DeviceController::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DeviceController::ResultOf::Resume DeviceController::SyncClient::Resume(uint32_t target_system_state) {
+ return ResultOf::Resume(::zx::unowned_channel(this->channel_), std::move(target_system_state));
+}
+
+DeviceController::ResultOf::Resume DeviceController::Call::Resume(::zx::unowned_channel _client_end, uint32_t target_system_state) {
+ return ResultOf::Resume(std::move(_client_end), std::move(target_system_state));
+}
+
+template <>
+DeviceController::UnownedResultOf::Resume_Impl<DeviceController::ResumeResponse>::Resume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ResumeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ResumeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ResumeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ResumeRequest*>(_request_buffer.data());
+ _request.target_system_state = std::move(target_system_state);
+ _request_buffer.set_actual(sizeof(ResumeRequest));
+ ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DeviceController::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DeviceController::UnownedResultOf::Resume DeviceController::SyncClient::Resume(::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resume(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(target_system_state), std::move(_response_buffer));
+}
+
+DeviceController::UnownedResultOf::Resume DeviceController::Call::Resume(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resume(std::move(_client_end), std::move(_request_buffer), std::move(target_system_state), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DeviceController::ResumeResponse> DeviceController::InPlace::Resume(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer) {
+ DeviceController::SetTransactionHeaderFor::ResumeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::ResumeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ResumeRequest, ResumeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceController::ResumeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+DeviceController::ResultOf::CompleteCompatibilityTests_Impl::CompleteCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CompleteCompatibilityTestsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CompleteCompatibilityTestsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CompleteCompatibilityTestsRequest*>(_write_bytes);
+ _request.status = std::move(status);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CompleteCompatibilityTestsRequest));
+ ::fidl::DecodedMessage<CompleteCompatibilityTestsRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DeviceController::InPlace::CompleteCompatibilityTests(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceController::ResultOf::CompleteCompatibilityTests DeviceController::SyncClient::CompleteCompatibilityTests(::llcpp::fuchsia::device::manager::CompatibilityTestStatus status) {
+ return ResultOf::CompleteCompatibilityTests(::zx::unowned_channel(this->channel_), std::move(status));
+}
+
+DeviceController::ResultOf::CompleteCompatibilityTests DeviceController::Call::CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status) {
+ return ResultOf::CompleteCompatibilityTests(std::move(_client_end), std::move(status));
+}
+
+
+DeviceController::UnownedResultOf::CompleteCompatibilityTests_Impl::CompleteCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status) {
+ if (_request_buffer.capacity() < CompleteCompatibilityTestsRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CompleteCompatibilityTestsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CompleteCompatibilityTestsRequest*>(_request_buffer.data());
+ _request.status = std::move(status);
+ _request_buffer.set_actual(sizeof(CompleteCompatibilityTestsRequest));
+ ::fidl::DecodedMessage<CompleteCompatibilityTestsRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DeviceController::InPlace::CompleteCompatibilityTests(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceController::UnownedResultOf::CompleteCompatibilityTests DeviceController::SyncClient::CompleteCompatibilityTests(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status) {
+ return UnownedResultOf::CompleteCompatibilityTests(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(status));
+}
+
+DeviceController::UnownedResultOf::CompleteCompatibilityTests DeviceController::Call::CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status) {
+ return UnownedResultOf::CompleteCompatibilityTests(std::move(_client_end), std::move(_request_buffer), std::move(status));
+}
+
+::fidl::internal::StatusAndError DeviceController::InPlace::CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CompleteCompatibilityTestsRequest> params) {
+ DeviceController::SetTransactionHeaderFor::CompleteCompatibilityTestsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool DeviceController::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDeviceController_BindDriver_Ordinal:
+ case kDeviceController_BindDriver_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindDriverRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->BindDriver(std::move(message->driver_path), std::move(message->driver),
+ Interface::BindDriverCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceController_ConnectProxy_Ordinal:
+ case kDeviceController_ConnectProxy_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConnectProxyRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ConnectProxy(std::move(message->shadow),
+ Interface::ConnectProxyCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceController_Init_Ordinal:
+ case kDeviceController_Init_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<InitRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Init(
+ Interface::InitCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceController_Unbind_Ordinal:
+ case kDeviceController_Unbind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnbindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Unbind(
+ Interface::UnbindCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceController_CompleteRemoval_Ordinal:
+ case kDeviceController_CompleteRemoval_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CompleteRemovalRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->CompleteRemoval(
+ Interface::CompleteRemovalCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceController_Suspend_Ordinal:
+ case kDeviceController_Suspend_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SuspendRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Suspend(std::move(message->flags),
+ Interface::SuspendCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceController_Resume_Ordinal:
+ case kDeviceController_Resume_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ResumeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Resume(std::move(message->target_system_state),
+ Interface::ResumeCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceController_CompleteCompatibilityTests_Ordinal:
+ case kDeviceController_CompleteCompatibilityTests_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CompleteCompatibilityTestsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CompleteCompatibilityTests(std::move(message->status),
+ Interface::CompleteCompatibilityTestsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DeviceController::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DeviceController::Interface::BindDriverCompleterBase::Reply(int32_t status, ::zx::channel test_output) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDriverResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<BindDriverResponse*>(_write_bytes);
+ DeviceController::SetTransactionHeaderFor::BindDriverResponse(
+ ::fidl::DecodedMessage<BindDriverResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindDriverResponse::PrimarySize,
+ BindDriverResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.test_output = std::move(test_output);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(BindDriverResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<BindDriverResponse>(std::move(_response_bytes)));
+}
+
+void DeviceController::Interface::BindDriverCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::channel test_output) {
+ if (_buffer.capacity() < BindDriverResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<BindDriverResponse*>(_buffer.data());
+ DeviceController::SetTransactionHeaderFor::BindDriverResponse(
+ ::fidl::DecodedMessage<BindDriverResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindDriverResponse::PrimarySize,
+ BindDriverResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.test_output = std::move(test_output);
+ _buffer.set_actual(sizeof(BindDriverResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<BindDriverResponse>(std::move(_buffer)));
+}
+
+void DeviceController::Interface::BindDriverCompleterBase::Reply(::fidl::DecodedMessage<BindDriverResponse> params) {
+ DeviceController::SetTransactionHeaderFor::BindDriverResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DeviceController::Interface::InitCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InitResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<InitResponse*>(_write_bytes);
+ DeviceController::SetTransactionHeaderFor::InitResponse(
+ ::fidl::DecodedMessage<InitResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InitResponse::PrimarySize,
+ InitResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(InitResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<InitResponse>(std::move(_response_bytes)));
+}
+
+void DeviceController::Interface::InitCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < InitResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<InitResponse*>(_buffer.data());
+ DeviceController::SetTransactionHeaderFor::InitResponse(
+ ::fidl::DecodedMessage<InitResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InitResponse::PrimarySize,
+ InitResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(InitResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<InitResponse>(std::move(_buffer)));
+}
+
+void DeviceController::Interface::InitCompleterBase::Reply(::fidl::DecodedMessage<InitResponse> params) {
+ DeviceController::SetTransactionHeaderFor::InitResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DeviceController::Interface::UnbindCompleterBase::Reply(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnbindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UnbindResponse _response = {};
+ DeviceController::SetTransactionHeaderFor::UnbindResponse(
+ ::fidl::DecodedMessage<UnbindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnbindResponse::PrimarySize,
+ UnbindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DeviceController::Interface::UnbindCompleterBase::ReplySuccess() {
+ DeviceController_Unbind_Response response;
+
+ Reply(DeviceController_Unbind_Result::WithResponse(&response));
+}
+void DeviceController::Interface::UnbindCompleterBase::ReplyError(int32_t error) {
+ Reply(DeviceController_Unbind_Result::WithErr(&error));
+}
+
+void DeviceController::Interface::UnbindCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result result) {
+ if (_buffer.capacity() < UnbindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UnbindResponse _response = {};
+ DeviceController::SetTransactionHeaderFor::UnbindResponse(
+ ::fidl::DecodedMessage<UnbindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnbindResponse::PrimarySize,
+ UnbindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DeviceController::Interface::UnbindCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ DeviceController_Unbind_Response response;
+
+ Reply(std::move(_buffer), DeviceController_Unbind_Result::WithResponse(&response));
+}
+
+void DeviceController::Interface::UnbindCompleterBase::Reply(::fidl::DecodedMessage<UnbindResponse> params) {
+ DeviceController::SetTransactionHeaderFor::UnbindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DeviceController::Interface::CompleteRemovalCompleterBase::Reply(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CompleteRemovalResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ CompleteRemovalResponse _response = {};
+ DeviceController::SetTransactionHeaderFor::CompleteRemovalResponse(
+ ::fidl::DecodedMessage<CompleteRemovalResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CompleteRemovalResponse::PrimarySize,
+ CompleteRemovalResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DeviceController::Interface::CompleteRemovalCompleterBase::ReplySuccess() {
+ DeviceController_CompleteRemoval_Response response;
+
+ Reply(DeviceController_CompleteRemoval_Result::WithResponse(&response));
+}
+void DeviceController::Interface::CompleteRemovalCompleterBase::ReplyError(int32_t error) {
+ Reply(DeviceController_CompleteRemoval_Result::WithErr(&error));
+}
+
+void DeviceController::Interface::CompleteRemovalCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result result) {
+ if (_buffer.capacity() < CompleteRemovalResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleteRemovalResponse _response = {};
+ DeviceController::SetTransactionHeaderFor::CompleteRemovalResponse(
+ ::fidl::DecodedMessage<CompleteRemovalResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CompleteRemovalResponse::PrimarySize,
+ CompleteRemovalResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DeviceController::Interface::CompleteRemovalCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ DeviceController_CompleteRemoval_Response response;
+
+ Reply(std::move(_buffer), DeviceController_CompleteRemoval_Result::WithResponse(&response));
+}
+
+void DeviceController::Interface::CompleteRemovalCompleterBase::Reply(::fidl::DecodedMessage<CompleteRemovalResponse> params) {
+ DeviceController::SetTransactionHeaderFor::CompleteRemovalResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DeviceController::Interface::SuspendCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SuspendResponse*>(_write_bytes);
+ DeviceController::SetTransactionHeaderFor::SuspendResponse(
+ ::fidl::DecodedMessage<SuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendResponse::PrimarySize,
+ SuspendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_response_bytes)));
+}
+
+void DeviceController::Interface::SuspendCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SuspendResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SuspendResponse*>(_buffer.data());
+ DeviceController::SetTransactionHeaderFor::SuspendResponse(
+ ::fidl::DecodedMessage<SuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendResponse::PrimarySize,
+ SuspendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SuspendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_buffer)));
+}
+
+void DeviceController::Interface::SuspendCompleterBase::Reply(::fidl::DecodedMessage<SuspendResponse> params) {
+ DeviceController::SetTransactionHeaderFor::SuspendResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DeviceController::Interface::ResumeCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ResumeResponse*>(_write_bytes);
+ DeviceController::SetTransactionHeaderFor::ResumeResponse(
+ ::fidl::DecodedMessage<ResumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResumeResponse::PrimarySize,
+ ResumeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ResumeResponse>(std::move(_response_bytes)));
+}
+
+void DeviceController::Interface::ResumeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ResumeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ResumeResponse*>(_buffer.data());
+ DeviceController::SetTransactionHeaderFor::ResumeResponse(
+ ::fidl::DecodedMessage<ResumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResumeResponse::PrimarySize,
+ ResumeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ResumeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ResumeResponse>(std::move(_buffer)));
+}
+
+void DeviceController::Interface::ResumeCompleterBase::Reply(::fidl::DecodedMessage<ResumeResponse> params) {
+ DeviceController::SetTransactionHeaderFor::ResumeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DeviceController::SetTransactionHeaderFor::BindDriverRequest(const ::fidl::DecodedMessage<DeviceController::BindDriverRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_BindDriver_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DeviceController::SetTransactionHeaderFor::BindDriverResponse(const ::fidl::DecodedMessage<DeviceController::BindDriverResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_BindDriver_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceController::SetTransactionHeaderFor::ConnectProxyRequest(const ::fidl::DecodedMessage<DeviceController::ConnectProxyRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_ConnectProxy_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceController::SetTransactionHeaderFor::InitRequest(const ::fidl::DecodedMessage<DeviceController::InitRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_Init_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DeviceController::SetTransactionHeaderFor::InitResponse(const ::fidl::DecodedMessage<DeviceController::InitResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_Init_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceController::SetTransactionHeaderFor::UnbindRequest(const ::fidl::DecodedMessage<DeviceController::UnbindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_Unbind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DeviceController::SetTransactionHeaderFor::UnbindResponse(const ::fidl::DecodedMessage<DeviceController::UnbindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_Unbind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceController::SetTransactionHeaderFor::CompleteRemovalRequest(const ::fidl::DecodedMessage<DeviceController::CompleteRemovalRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_CompleteRemoval_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DeviceController::SetTransactionHeaderFor::CompleteRemovalResponse(const ::fidl::DecodedMessage<DeviceController::CompleteRemovalResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_CompleteRemoval_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceController::SetTransactionHeaderFor::SuspendRequest(const ::fidl::DecodedMessage<DeviceController::SuspendRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_Suspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DeviceController::SetTransactionHeaderFor::SuspendResponse(const ::fidl::DecodedMessage<DeviceController::SuspendResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_Suspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceController::SetTransactionHeaderFor::ResumeRequest(const ::fidl::DecodedMessage<DeviceController::ResumeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_Resume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DeviceController::SetTransactionHeaderFor::ResumeResponse(const ::fidl::DecodedMessage<DeviceController::ResumeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_Resume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceController::SetTransactionHeaderFor::CompleteCompatibilityTestsRequest(const ::fidl::DecodedMessage<DeviceController::CompleteCompatibilityTestsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceController_CompleteCompatibilityTests_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_AddDevice_Ordinal = 0x4a5e94e200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_AddDevice_GenOrdinal = 0x2790f5d086adbf8flu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_AddDeviceInvisible_Ordinal = 0x6bf4eece00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_AddDeviceInvisible_GenOrdinal = 0x1c96c2aa95cb3b9blu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_ScheduleRemove_Ordinal = 0x65a3b60600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_ScheduleRemove_GenOrdinal = 0x1bdeb4d5d1f4d21elu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleRemoveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleRemoveResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_ScheduleUnbindChildren_Ordinal = 0x59a4dcaf00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_ScheduleUnbindChildren_GenOrdinal = 0x658a6d68027b7139lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleUnbindChildrenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleUnbindChildrenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_MakeVisible_Ordinal = 0x52d55e5c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_MakeVisible_GenOrdinal = 0x37d4026fe66cf62blu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorMakeVisibleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorMakeVisibleResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_BindDevice_Ordinal = 0x5012286100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_BindDevice_GenOrdinal = 0x274db0bd334639calu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorBindDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorBindDeviceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_GetTopologicalPath_Ordinal = 0x69b2d39100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_GetTopologicalPath_GenOrdinal = 0x319ccef1252fd6bflu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetTopologicalPathRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetTopologicalPathResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_LoadFirmware_Ordinal = 0x7ad6a07500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_LoadFirmware_GenOrdinal = 0x5c24700e7a9815bdlu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorLoadFirmwareRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorLoadFirmwareResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_GetMetadata_Ordinal = 0x2fabb5cd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_GetMetadata_GenOrdinal = 0x34abe1351145bf3flu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_GetMetadataSize_Ordinal = 0x313e071100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_GetMetadataSize_GenOrdinal = 0x290826b5b7483d61lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataSizeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_AddMetadata_Ordinal = 0x31ea228600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_AddMetadata_GenOrdinal = 0x7acb84ea4eb23c94lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddMetadataRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddMetadataResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_PublishMetadata_Ordinal = 0x1ad94f5300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_PublishMetadata_GenOrdinal = 0x3355f89ab7bf7c65lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorPublishMetadataRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorPublishMetadataResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_AddCompositeDevice_Ordinal = 0x4838d35600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_AddCompositeDevice_GenOrdinal = 0x1610b2d89769d054lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_DirectoryWatch_Ordinal = 0x2a37159400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_DirectoryWatch_GenOrdinal = 0x4299b4cc9acc68e4lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorDirectoryWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorDirectoryWatchResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_RunCompatibilityTests_Ordinal = 0x167858fb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCoordinator_RunCompatibilityTests_GenOrdinal = 0x634a2580075931b2lu;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsResponseTable;
+
+} // namespace
+template <>
+Coordinator::ResultOf::AddDevice_Impl<Coordinator::AddDeviceResponse>::AddDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddDeviceRequest _request = {};
+ _request.coordinator = std::move(coordinator);
+ _request.device_controller = std::move(device_controller);
+ _request.props = std::move(props);
+ _request.name = std::move(name);
+ _request.protocol_id = std::move(protocol_id);
+ _request.driver_path = std::move(driver_path);
+ _request.args = std::move(args);
+ _request.device_add_config = std::move(device_add_config);
+ _request.has_init = std::move(has_init);
+ _request.client_remote = std::move(client_remote);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::AddDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::AddDevice Coordinator::SyncClient::AddDevice(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote) {
+ return ResultOf::AddDevice(::zx::unowned_channel(this->channel_), std::move(coordinator), std::move(device_controller), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(device_add_config), std::move(has_init), std::move(client_remote));
+}
+
+Coordinator::ResultOf::AddDevice Coordinator::Call::AddDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote) {
+ return ResultOf::AddDevice(std::move(_client_end), std::move(coordinator), std::move(device_controller), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(device_add_config), std::move(has_init), std::move(client_remote));
+}
+
+template <>
+Coordinator::UnownedResultOf::AddDevice_Impl<Coordinator::AddDeviceResponse>::AddDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AddDeviceRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AddDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ AddDeviceRequest _request = {};
+ _request.coordinator = std::move(coordinator);
+ _request.device_controller = std::move(device_controller);
+ _request.props = std::move(props);
+ _request.name = std::move(name);
+ _request.protocol_id = std::move(protocol_id);
+ _request.driver_path = std::move(driver_path);
+ _request.args = std::move(args);
+ _request.device_add_config = std::move(device_add_config);
+ _request.has_init = std::move(has_init);
+ _request.client_remote = std::move(client_remote);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::AddDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::AddDevice Coordinator::SyncClient::AddDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddDevice(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(coordinator), std::move(device_controller), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(device_add_config), std::move(has_init), std::move(client_remote), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::AddDevice Coordinator::Call::AddDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddDevice(std::move(_client_end), std::move(_request_buffer), std::move(coordinator), std::move(device_controller), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(device_add_config), std::move(has_init), std::move(client_remote), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::AddDeviceResponse> Coordinator::InPlace::AddDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::AddDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::AddDeviceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AddDeviceRequest, AddDeviceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::AddDeviceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::AddDeviceInvisible_Impl<Coordinator::AddDeviceInvisibleResponse>::AddDeviceInvisible_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceInvisibleRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddDeviceInvisibleRequest _request = {};
+ _request.coordinator = std::move(coordinator);
+ _request.device_controller = std::move(device_controller);
+ _request.props = std::move(props);
+ _request.name = std::move(name);
+ _request.protocol_id = std::move(protocol_id);
+ _request.driver_path = std::move(driver_path);
+ _request.args = std::move(args);
+ _request.has_init = std::move(has_init);
+ _request.client_remote = std::move(client_remote);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddDeviceInvisibleRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::AddDeviceInvisible(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::AddDeviceInvisible Coordinator::SyncClient::AddDeviceInvisible(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote) {
+ return ResultOf::AddDeviceInvisible(::zx::unowned_channel(this->channel_), std::move(coordinator), std::move(device_controller), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(has_init), std::move(client_remote));
+}
+
+Coordinator::ResultOf::AddDeviceInvisible Coordinator::Call::AddDeviceInvisible(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote) {
+ return ResultOf::AddDeviceInvisible(std::move(_client_end), std::move(coordinator), std::move(device_controller), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(has_init), std::move(client_remote));
+}
+
+template <>
+Coordinator::UnownedResultOf::AddDeviceInvisible_Impl<Coordinator::AddDeviceInvisibleResponse>::AddDeviceInvisible_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AddDeviceInvisibleRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AddDeviceInvisibleResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ AddDeviceInvisibleRequest _request = {};
+ _request.coordinator = std::move(coordinator);
+ _request.device_controller = std::move(device_controller);
+ _request.props = std::move(props);
+ _request.name = std::move(name);
+ _request.protocol_id = std::move(protocol_id);
+ _request.driver_path = std::move(driver_path);
+ _request.args = std::move(args);
+ _request.has_init = std::move(has_init);
+ _request.client_remote = std::move(client_remote);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddDeviceInvisibleRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::AddDeviceInvisible(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::AddDeviceInvisible Coordinator::SyncClient::AddDeviceInvisible(::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddDeviceInvisible(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(coordinator), std::move(device_controller), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(has_init), std::move(client_remote), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::AddDeviceInvisible Coordinator::Call::AddDeviceInvisible(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddDeviceInvisible(std::move(_client_end), std::move(_request_buffer), std::move(coordinator), std::move(device_controller), std::move(props), std::move(name), std::move(protocol_id), std::move(driver_path), std::move(args), std::move(has_init), std::move(client_remote), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::AddDeviceInvisibleResponse> Coordinator::InPlace::AddDeviceInvisible(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceInvisibleRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::AddDeviceInvisibleRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::AddDeviceInvisibleResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AddDeviceInvisibleRequest, AddDeviceInvisibleResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::AddDeviceInvisibleResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Coordinator::ResultOf::ScheduleRemove_Impl::ScheduleRemove_Impl(::zx::unowned_channel _client_end, bool unbind_self) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleRemoveRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ScheduleRemoveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ScheduleRemoveRequest*>(_write_bytes);
+ _request.unbind_self = std::move(unbind_self);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduleRemoveRequest));
+ ::fidl::DecodedMessage<ScheduleRemoveRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Coordinator::InPlace::ScheduleRemove(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Coordinator::ResultOf::ScheduleRemove Coordinator::SyncClient::ScheduleRemove(bool unbind_self) {
+ return ResultOf::ScheduleRemove(::zx::unowned_channel(this->channel_), std::move(unbind_self));
+}
+
+Coordinator::ResultOf::ScheduleRemove Coordinator::Call::ScheduleRemove(::zx::unowned_channel _client_end, bool unbind_self) {
+ return ResultOf::ScheduleRemove(std::move(_client_end), std::move(unbind_self));
+}
+
+
+Coordinator::UnownedResultOf::ScheduleRemove_Impl::ScheduleRemove_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool unbind_self) {
+ if (_request_buffer.capacity() < ScheduleRemoveRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ScheduleRemoveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ScheduleRemoveRequest*>(_request_buffer.data());
+ _request.unbind_self = std::move(unbind_self);
+ _request_buffer.set_actual(sizeof(ScheduleRemoveRequest));
+ ::fidl::DecodedMessage<ScheduleRemoveRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Coordinator::InPlace::ScheduleRemove(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Coordinator::UnownedResultOf::ScheduleRemove Coordinator::SyncClient::ScheduleRemove(::fidl::BytePart _request_buffer, bool unbind_self) {
+ return UnownedResultOf::ScheduleRemove(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(unbind_self));
+}
+
+Coordinator::UnownedResultOf::ScheduleRemove Coordinator::Call::ScheduleRemove(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool unbind_self) {
+ return UnownedResultOf::ScheduleRemove(std::move(_client_end), std::move(_request_buffer), std::move(unbind_self));
+}
+
+::fidl::internal::StatusAndError Coordinator::InPlace::ScheduleRemove(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ScheduleRemoveRequest> params) {
+ Coordinator::SetTransactionHeaderFor::ScheduleRemoveRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Coordinator::ResultOf::ScheduleUnbindChildren_Impl::ScheduleUnbindChildren_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleUnbindChildrenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ScheduleUnbindChildrenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduleUnbindChildrenRequest));
+ ::fidl::DecodedMessage<ScheduleUnbindChildrenRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Coordinator::InPlace::ScheduleUnbindChildren(std::move(_client_end)));
+}
+
+Coordinator::ResultOf::ScheduleUnbindChildren Coordinator::SyncClient::ScheduleUnbindChildren() {
+ return ResultOf::ScheduleUnbindChildren(::zx::unowned_channel(this->channel_));
+}
+
+Coordinator::ResultOf::ScheduleUnbindChildren Coordinator::Call::ScheduleUnbindChildren(::zx::unowned_channel _client_end) {
+ return ResultOf::ScheduleUnbindChildren(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Coordinator::InPlace::ScheduleUnbindChildren(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(ScheduleUnbindChildrenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ScheduleUnbindChildrenRequest> params(std::move(_request_buffer));
+ Coordinator::SetTransactionHeaderFor::ScheduleUnbindChildrenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Coordinator::ResultOf::MakeVisible_Impl<Coordinator::MakeVisibleResponse>::MakeVisible_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MakeVisibleRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, MakeVisibleRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(MakeVisibleRequest));
+ ::fidl::DecodedMessage<MakeVisibleRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Coordinator::InPlace::MakeVisible(std::move(_client_end), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::MakeVisible Coordinator::SyncClient::MakeVisible() {
+ return ResultOf::MakeVisible(::zx::unowned_channel(this->channel_));
+}
+
+Coordinator::ResultOf::MakeVisible Coordinator::Call::MakeVisible(::zx::unowned_channel _client_end) {
+ return ResultOf::MakeVisible(std::move(_client_end));
+}
+
+template <>
+Coordinator::UnownedResultOf::MakeVisible_Impl<Coordinator::MakeVisibleResponse>::MakeVisible_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(MakeVisibleRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, MakeVisibleRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(MakeVisibleRequest));
+ ::fidl::DecodedMessage<MakeVisibleRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Coordinator::InPlace::MakeVisible(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::MakeVisible Coordinator::SyncClient::MakeVisible(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::MakeVisible(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::MakeVisible Coordinator::Call::MakeVisible(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::MakeVisible(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::MakeVisibleResponse> Coordinator::InPlace::MakeVisible(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(MakeVisibleRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<MakeVisibleRequest> params(std::move(_request_buffer));
+ Coordinator::SetTransactionHeaderFor::MakeVisibleRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::MakeVisibleResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<MakeVisibleRequest, MakeVisibleResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::MakeVisibleResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::BindDevice_Impl<Coordinator::BindDeviceResponse>::BindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver_path) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDeviceRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ BindDeviceRequest _request = {};
+ _request.driver_path = std::move(driver_path);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::BindDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::BindDevice Coordinator::SyncClient::BindDevice(::fidl::StringView driver_path) {
+ return ResultOf::BindDevice(::zx::unowned_channel(this->channel_), std::move(driver_path));
+}
+
+Coordinator::ResultOf::BindDevice Coordinator::Call::BindDevice(::zx::unowned_channel _client_end, ::fidl::StringView driver_path) {
+ return ResultOf::BindDevice(std::move(_client_end), std::move(driver_path));
+}
+
+template <>
+Coordinator::UnownedResultOf::BindDevice_Impl<Coordinator::BindDeviceResponse>::BindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BindDeviceRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BindDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ BindDeviceRequest _request = {};
+ _request.driver_path = std::move(driver_path);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::BindDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::BindDevice Coordinator::SyncClient::BindDevice(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::BindDevice(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(driver_path), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::BindDevice Coordinator::Call::BindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::BindDevice(std::move(_client_end), std::move(_request_buffer), std::move(driver_path), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::BindDeviceResponse> Coordinator::InPlace::BindDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDeviceRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::BindDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::BindDeviceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BindDeviceRequest, BindDeviceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::BindDeviceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::GetTopologicalPath_Impl<Coordinator::GetTopologicalPathResponse>::GetTopologicalPath_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTopologicalPathRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTopologicalPathRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTopologicalPathRequest));
+ ::fidl::DecodedMessage<GetTopologicalPathRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Coordinator::InPlace::GetTopologicalPath(std::move(_client_end), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::GetTopologicalPath Coordinator::SyncClient::GetTopologicalPath() {
+ return ResultOf::GetTopologicalPath(::zx::unowned_channel(this->channel_));
+}
+
+Coordinator::ResultOf::GetTopologicalPath Coordinator::Call::GetTopologicalPath(::zx::unowned_channel _client_end) {
+ return ResultOf::GetTopologicalPath(std::move(_client_end));
+}
+
+template <>
+Coordinator::UnownedResultOf::GetTopologicalPath_Impl<Coordinator::GetTopologicalPathResponse>::GetTopologicalPath_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTopologicalPathRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTopologicalPathRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTopologicalPathRequest));
+ ::fidl::DecodedMessage<GetTopologicalPathRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Coordinator::InPlace::GetTopologicalPath(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::GetTopologicalPath Coordinator::SyncClient::GetTopologicalPath(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTopologicalPath(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::GetTopologicalPath Coordinator::Call::GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTopologicalPath(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::GetTopologicalPathResponse> Coordinator::InPlace::GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTopologicalPathRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTopologicalPathRequest> params(std::move(_request_buffer));
+ Coordinator::SetTransactionHeaderFor::GetTopologicalPathRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::GetTopologicalPathResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTopologicalPathRequest, GetTopologicalPathResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::GetTopologicalPathResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::LoadFirmware_Impl<Coordinator::LoadFirmwareResponse>::LoadFirmware_Impl(::zx::unowned_channel _client_end, ::fidl::StringView fw_path) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LoadFirmwareRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LoadFirmwareRequest _request = {};
+ _request.fw_path = std::move(fw_path);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LoadFirmwareRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::LoadFirmware(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::LoadFirmware Coordinator::SyncClient::LoadFirmware(::fidl::StringView fw_path) {
+ return ResultOf::LoadFirmware(::zx::unowned_channel(this->channel_), std::move(fw_path));
+}
+
+Coordinator::ResultOf::LoadFirmware Coordinator::Call::LoadFirmware(::zx::unowned_channel _client_end, ::fidl::StringView fw_path) {
+ return ResultOf::LoadFirmware(std::move(_client_end), std::move(fw_path));
+}
+
+template <>
+Coordinator::UnownedResultOf::LoadFirmware_Impl<Coordinator::LoadFirmwareResponse>::LoadFirmware_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LoadFirmwareRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LoadFirmwareResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LoadFirmwareRequest _request = {};
+ _request.fw_path = std::move(fw_path);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LoadFirmwareRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::LoadFirmware(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::LoadFirmware Coordinator::SyncClient::LoadFirmware(::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LoadFirmware(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(fw_path), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::LoadFirmware Coordinator::Call::LoadFirmware(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LoadFirmware(std::move(_client_end), std::move(_request_buffer), std::move(fw_path), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::LoadFirmwareResponse> Coordinator::InPlace::LoadFirmware(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LoadFirmwareRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::LoadFirmwareRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::LoadFirmwareResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LoadFirmwareRequest, LoadFirmwareResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::LoadFirmwareResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::GetMetadata_Impl<Coordinator::GetMetadataResponse>::GetMetadata_Impl(::zx::unowned_channel _client_end, uint32_t key) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetadataRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetMetadataRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetMetadataRequest*>(_write_bytes);
+ _request.key = std::move(key);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMetadataRequest));
+ ::fidl::DecodedMessage<GetMetadataRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Coordinator::InPlace::GetMetadata(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::GetMetadata Coordinator::SyncClient::GetMetadata(uint32_t key) {
+ return ResultOf::GetMetadata(::zx::unowned_channel(this->channel_), std::move(key));
+}
+
+Coordinator::ResultOf::GetMetadata Coordinator::Call::GetMetadata(::zx::unowned_channel _client_end, uint32_t key) {
+ return ResultOf::GetMetadata(std::move(_client_end), std::move(key));
+}
+
+template <>
+Coordinator::UnownedResultOf::GetMetadata_Impl<Coordinator::GetMetadataResponse>::GetMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetMetadataRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetMetadataResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetMetadataRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetMetadataRequest*>(_request_buffer.data());
+ _request.key = std::move(key);
+ _request_buffer.set_actual(sizeof(GetMetadataRequest));
+ ::fidl::DecodedMessage<GetMetadataRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Coordinator::InPlace::GetMetadata(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::GetMetadata Coordinator::SyncClient::GetMetadata(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMetadata(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(key), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::GetMetadata Coordinator::Call::GetMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMetadata(std::move(_client_end), std::move(_request_buffer), std::move(key), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::GetMetadataResponse> Coordinator::InPlace::GetMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMetadataRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::GetMetadataRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::GetMetadataResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetMetadataRequest, GetMetadataResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::GetMetadataResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::GetMetadataSize_Impl<Coordinator::GetMetadataSizeResponse>::GetMetadataSize_Impl(::zx::unowned_channel _client_end, uint32_t key) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetadataSizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetMetadataSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetMetadataSizeRequest*>(_write_bytes);
+ _request.key = std::move(key);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMetadataSizeRequest));
+ ::fidl::DecodedMessage<GetMetadataSizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Coordinator::InPlace::GetMetadataSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::GetMetadataSize Coordinator::SyncClient::GetMetadataSize(uint32_t key) {
+ return ResultOf::GetMetadataSize(::zx::unowned_channel(this->channel_), std::move(key));
+}
+
+Coordinator::ResultOf::GetMetadataSize Coordinator::Call::GetMetadataSize(::zx::unowned_channel _client_end, uint32_t key) {
+ return ResultOf::GetMetadataSize(std::move(_client_end), std::move(key));
+}
+
+template <>
+Coordinator::UnownedResultOf::GetMetadataSize_Impl<Coordinator::GetMetadataSizeResponse>::GetMetadataSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetMetadataSizeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetMetadataSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetMetadataSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetMetadataSizeRequest*>(_request_buffer.data());
+ _request.key = std::move(key);
+ _request_buffer.set_actual(sizeof(GetMetadataSizeRequest));
+ ::fidl::DecodedMessage<GetMetadataSizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Coordinator::InPlace::GetMetadataSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::GetMetadataSize Coordinator::SyncClient::GetMetadataSize(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMetadataSize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(key), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::GetMetadataSize Coordinator::Call::GetMetadataSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMetadataSize(std::move(_client_end), std::move(_request_buffer), std::move(key), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::GetMetadataSizeResponse> Coordinator::InPlace::GetMetadataSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMetadataSizeRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::GetMetadataSizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::GetMetadataSizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetMetadataSizeRequest, GetMetadataSizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::GetMetadataSizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::AddMetadata_Impl<Coordinator::AddMetadataResponse>::AddMetadata_Impl(::zx::unowned_channel _client_end, uint32_t key, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddMetadataRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddMetadataRequest _request = {};
+ _request.key = std::move(key);
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddMetadataRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::AddMetadata(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::AddMetadata Coordinator::SyncClient::AddMetadata(uint32_t key, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::AddMetadata(::zx::unowned_channel(this->channel_), std::move(key), std::move(data));
+}
+
+Coordinator::ResultOf::AddMetadata Coordinator::Call::AddMetadata(::zx::unowned_channel _client_end, uint32_t key, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::AddMetadata(std::move(_client_end), std::move(key), std::move(data));
+}
+
+template <>
+Coordinator::UnownedResultOf::AddMetadata_Impl<Coordinator::AddMetadataResponse>::AddMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AddMetadataRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AddMetadataResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ AddMetadataRequest _request = {};
+ _request.key = std::move(key);
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddMetadataRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::AddMetadata(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::AddMetadata Coordinator::SyncClient::AddMetadata(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddMetadata(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(key), std::move(data), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::AddMetadata Coordinator::Call::AddMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddMetadata(std::move(_client_end), std::move(_request_buffer), std::move(key), std::move(data), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::AddMetadataResponse> Coordinator::InPlace::AddMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddMetadataRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::AddMetadataRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::AddMetadataResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AddMetadataRequest, AddMetadataResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::AddMetadataResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::PublishMetadata_Impl<Coordinator::PublishMetadataResponse>::PublishMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PublishMetadataRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ PublishMetadataRequest _request = {};
+ _request.device_path = std::move(device_path);
+ _request.key = std::move(key);
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<PublishMetadataRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::PublishMetadata(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::PublishMetadata Coordinator::SyncClient::PublishMetadata(::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::PublishMetadata(::zx::unowned_channel(this->channel_), std::move(device_path), std::move(key), std::move(data));
+}
+
+Coordinator::ResultOf::PublishMetadata Coordinator::Call::PublishMetadata(::zx::unowned_channel _client_end, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::PublishMetadata(std::move(_client_end), std::move(device_path), std::move(key), std::move(data));
+}
+
+template <>
+Coordinator::UnownedResultOf::PublishMetadata_Impl<Coordinator::PublishMetadataResponse>::PublishMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < PublishMetadataRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<PublishMetadataResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ PublishMetadataRequest _request = {};
+ _request.device_path = std::move(device_path);
+ _request.key = std::move(key);
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<PublishMetadataRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::PublishMetadata(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::PublishMetadata Coordinator::SyncClient::PublishMetadata(::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::PublishMetadata(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(device_path), std::move(key), std::move(data), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::PublishMetadata Coordinator::Call::PublishMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::PublishMetadata(std::move(_client_end), std::move(_request_buffer), std::move(device_path), std::move(key), std::move(data), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::PublishMetadataResponse> Coordinator::InPlace::PublishMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PublishMetadataRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::PublishMetadataRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::PublishMetadataResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<PublishMetadataRequest, PublishMetadataResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::PublishMetadataResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::AddCompositeDevice_Impl<Coordinator::AddCompositeDeviceResponse>::AddCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddCompositeDeviceRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddCompositeDeviceRequest _request = {};
+ _request.name = std::move(name);
+ _request.comp_desc = std::move(comp_desc);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::AddCompositeDevice(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::AddCompositeDevice Coordinator::SyncClient::AddCompositeDevice(::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc) {
+ return ResultOf::AddCompositeDevice(::zx::unowned_channel(this->channel_), std::move(name), std::move(comp_desc));
+}
+
+Coordinator::ResultOf::AddCompositeDevice Coordinator::Call::AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc) {
+ return ResultOf::AddCompositeDevice(std::move(_client_end), std::move(name), std::move(comp_desc));
+}
+
+template <>
+Coordinator::UnownedResultOf::AddCompositeDevice_Impl<Coordinator::AddCompositeDeviceResponse>::AddCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AddCompositeDeviceRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AddCompositeDeviceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ AddCompositeDeviceRequest _request = {};
+ _request.name = std::move(name);
+ _request.comp_desc = std::move(comp_desc);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddCompositeDeviceRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Coordinator::InPlace::AddCompositeDevice(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::AddCompositeDevice Coordinator::SyncClient::AddCompositeDevice(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddCompositeDevice(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(name), std::move(comp_desc), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::AddCompositeDevice Coordinator::Call::AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddCompositeDevice(std::move(_client_end), std::move(_request_buffer), std::move(name), std::move(comp_desc), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::AddCompositeDeviceResponse> Coordinator::InPlace::AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddCompositeDeviceRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::AddCompositeDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::AddCompositeDeviceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AddCompositeDeviceRequest, AddCompositeDeviceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::AddCompositeDeviceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::DirectoryWatch_Impl<Coordinator::DirectoryWatchResponse>::DirectoryWatch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DirectoryWatchRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DirectoryWatchRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DirectoryWatchRequest*>(_write_bytes);
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DirectoryWatchRequest));
+ ::fidl::DecodedMessage<DirectoryWatchRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Coordinator::InPlace::DirectoryWatch(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::DirectoryWatch Coordinator::SyncClient::DirectoryWatch(uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ return ResultOf::DirectoryWatch(::zx::unowned_channel(this->channel_), std::move(mask), std::move(options), std::move(watcher));
+}
+
+Coordinator::ResultOf::DirectoryWatch Coordinator::Call::DirectoryWatch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ return ResultOf::DirectoryWatch(std::move(_client_end), std::move(mask), std::move(options), std::move(watcher));
+}
+
+template <>
+Coordinator::UnownedResultOf::DirectoryWatch_Impl<Coordinator::DirectoryWatchResponse>::DirectoryWatch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DirectoryWatchRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DirectoryWatchResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DirectoryWatchRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DirectoryWatchRequest*>(_request_buffer.data());
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ _request_buffer.set_actual(sizeof(DirectoryWatchRequest));
+ ::fidl::DecodedMessage<DirectoryWatchRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Coordinator::InPlace::DirectoryWatch(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::DirectoryWatch Coordinator::SyncClient::DirectoryWatch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DirectoryWatch(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::DirectoryWatch Coordinator::Call::DirectoryWatch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DirectoryWatch(std::move(_client_end), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::DirectoryWatchResponse> Coordinator::InPlace::DirectoryWatch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DirectoryWatchRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::DirectoryWatchRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::DirectoryWatchResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DirectoryWatchRequest, DirectoryWatchResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::DirectoryWatchResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Coordinator::ResultOf::RunCompatibilityTests_Impl<Coordinator::RunCompatibilityTestsResponse>::RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, int64_t hook_wait_time) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RunCompatibilityTestsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RunCompatibilityTestsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RunCompatibilityTestsRequest*>(_write_bytes);
+ _request.hook_wait_time = std::move(hook_wait_time);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RunCompatibilityTestsRequest));
+ ::fidl::DecodedMessage<RunCompatibilityTestsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Coordinator::InPlace::RunCompatibilityTests(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Coordinator::ResultOf::RunCompatibilityTests Coordinator::SyncClient::RunCompatibilityTests(int64_t hook_wait_time) {
+ return ResultOf::RunCompatibilityTests(::zx::unowned_channel(this->channel_), std::move(hook_wait_time));
+}
+
+Coordinator::ResultOf::RunCompatibilityTests Coordinator::Call::RunCompatibilityTests(::zx::unowned_channel _client_end, int64_t hook_wait_time) {
+ return ResultOf::RunCompatibilityTests(std::move(_client_end), std::move(hook_wait_time));
+}
+
+template <>
+Coordinator::UnownedResultOf::RunCompatibilityTests_Impl<Coordinator::RunCompatibilityTestsResponse>::RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RunCompatibilityTestsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RunCompatibilityTestsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RunCompatibilityTestsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RunCompatibilityTestsRequest*>(_request_buffer.data());
+ _request.hook_wait_time = std::move(hook_wait_time);
+ _request_buffer.set_actual(sizeof(RunCompatibilityTestsRequest));
+ ::fidl::DecodedMessage<RunCompatibilityTestsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Coordinator::InPlace::RunCompatibilityTests(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Coordinator::UnownedResultOf::RunCompatibilityTests Coordinator::SyncClient::RunCompatibilityTests(::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RunCompatibilityTests(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(hook_wait_time), std::move(_response_buffer));
+}
+
+Coordinator::UnownedResultOf::RunCompatibilityTests Coordinator::Call::RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RunCompatibilityTests(std::move(_client_end), std::move(_request_buffer), std::move(hook_wait_time), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Coordinator::RunCompatibilityTestsResponse> Coordinator::InPlace::RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RunCompatibilityTestsRequest> params, ::fidl::BytePart response_buffer) {
+ Coordinator::SetTransactionHeaderFor::RunCompatibilityTestsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::RunCompatibilityTestsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RunCompatibilityTestsRequest, RunCompatibilityTestsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Coordinator::RunCompatibilityTestsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Coordinator::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kCoordinator_AddDevice_Ordinal:
+ case kCoordinator_AddDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddDevice(std::move(message->coordinator), std::move(message->device_controller), std::move(message->props), std::move(message->name), std::move(message->protocol_id), std::move(message->driver_path), std::move(message->args), std::move(message->device_add_config), std::move(message->has_init), std::move(message->client_remote),
+ Interface::AddDeviceCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_AddDeviceInvisible_Ordinal:
+ case kCoordinator_AddDeviceInvisible_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddDeviceInvisibleRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddDeviceInvisible(std::move(message->coordinator), std::move(message->device_controller), std::move(message->props), std::move(message->name), std::move(message->protocol_id), std::move(message->driver_path), std::move(message->args), std::move(message->has_init), std::move(message->client_remote),
+ Interface::AddDeviceInvisibleCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_ScheduleRemove_Ordinal:
+ case kCoordinator_ScheduleRemove_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ScheduleRemoveRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ScheduleRemove(std::move(message->unbind_self),
+ Interface::ScheduleRemoveCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_ScheduleUnbindChildren_Ordinal:
+ case kCoordinator_ScheduleUnbindChildren_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ScheduleUnbindChildrenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ScheduleUnbindChildren(
+ Interface::ScheduleUnbindChildrenCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_MakeVisible_Ordinal:
+ case kCoordinator_MakeVisible_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<MakeVisibleRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->MakeVisible(
+ Interface::MakeVisibleCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_BindDevice_Ordinal:
+ case kCoordinator_BindDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->BindDevice(std::move(message->driver_path),
+ Interface::BindDeviceCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_GetTopologicalPath_Ordinal:
+ case kCoordinator_GetTopologicalPath_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTopologicalPathRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetTopologicalPath(
+ Interface::GetTopologicalPathCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_LoadFirmware_Ordinal:
+ case kCoordinator_LoadFirmware_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LoadFirmwareRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LoadFirmware(std::move(message->fw_path),
+ Interface::LoadFirmwareCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_GetMetadata_Ordinal:
+ case kCoordinator_GetMetadata_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetMetadataRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetMetadata(std::move(message->key),
+ Interface::GetMetadataCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_GetMetadataSize_Ordinal:
+ case kCoordinator_GetMetadataSize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetMetadataSizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetMetadataSize(std::move(message->key),
+ Interface::GetMetadataSizeCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_AddMetadata_Ordinal:
+ case kCoordinator_AddMetadata_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddMetadataRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddMetadata(std::move(message->key), std::move(message->data),
+ Interface::AddMetadataCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_PublishMetadata_Ordinal:
+ case kCoordinator_PublishMetadata_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<PublishMetadataRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->PublishMetadata(std::move(message->device_path), std::move(message->key), std::move(message->data),
+ Interface::PublishMetadataCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_AddCompositeDevice_Ordinal:
+ case kCoordinator_AddCompositeDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddCompositeDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddCompositeDevice(std::move(message->name), std::move(message->comp_desc),
+ Interface::AddCompositeDeviceCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_DirectoryWatch_Ordinal:
+ case kCoordinator_DirectoryWatch_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DirectoryWatchRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->DirectoryWatch(std::move(message->mask), std::move(message->options), std::move(message->watcher),
+ Interface::DirectoryWatchCompleter::Sync(txn));
+ return true;
+ }
+ case kCoordinator_RunCompatibilityTests_Ordinal:
+ case kCoordinator_RunCompatibilityTests_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RunCompatibilityTestsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RunCompatibilityTests(std::move(message->hook_wait_time),
+ Interface::RunCompatibilityTestsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Coordinator::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Coordinator::Interface::AddDeviceCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AddDeviceResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::AddDeviceResponse(
+ ::fidl::DecodedMessage<AddDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddDeviceResponse::PrimarySize,
+ AddDeviceResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::AddDeviceCompleterBase::ReplySuccess(uint64_t local_device_id) {
+ Coordinator_AddDevice_Response response;
+ response.local_device_id = std::move(local_device_id);
+
+ Reply(Coordinator_AddDevice_Result::WithResponse(&response));
+}
+void Coordinator::Interface::AddDeviceCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_AddDevice_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::AddDeviceCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result result) {
+ if (_buffer.capacity() < AddDeviceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AddDeviceResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::AddDeviceResponse(
+ ::fidl::DecodedMessage<AddDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddDeviceResponse::PrimarySize,
+ AddDeviceResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::AddDeviceCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t local_device_id) {
+ Coordinator_AddDevice_Response response;
+ response.local_device_id = std::move(local_device_id);
+
+ Reply(std::move(_buffer), Coordinator_AddDevice_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::AddDeviceCompleterBase::Reply(::fidl::DecodedMessage<AddDeviceResponse> params) {
+ Coordinator::SetTransactionHeaderFor::AddDeviceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::AddDeviceInvisibleCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddDeviceInvisibleResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AddDeviceInvisibleResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::AddDeviceInvisibleResponse(
+ ::fidl::DecodedMessage<AddDeviceInvisibleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddDeviceInvisibleResponse::PrimarySize,
+ AddDeviceInvisibleResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::AddDeviceInvisibleCompleterBase::ReplySuccess(uint64_t local_device_id) {
+ Coordinator_AddDeviceInvisible_Response response;
+ response.local_device_id = std::move(local_device_id);
+
+ Reply(Coordinator_AddDeviceInvisible_Result::WithResponse(&response));
+}
+void Coordinator::Interface::AddDeviceInvisibleCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_AddDeviceInvisible_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::AddDeviceInvisibleCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result result) {
+ if (_buffer.capacity() < AddDeviceInvisibleResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AddDeviceInvisibleResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::AddDeviceInvisibleResponse(
+ ::fidl::DecodedMessage<AddDeviceInvisibleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddDeviceInvisibleResponse::PrimarySize,
+ AddDeviceInvisibleResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::AddDeviceInvisibleCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t local_device_id) {
+ Coordinator_AddDeviceInvisible_Response response;
+ response.local_device_id = std::move(local_device_id);
+
+ Reply(std::move(_buffer), Coordinator_AddDeviceInvisible_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::AddDeviceInvisibleCompleterBase::Reply(::fidl::DecodedMessage<AddDeviceInvisibleResponse> params) {
+ Coordinator::SetTransactionHeaderFor::AddDeviceInvisibleResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::MakeVisibleCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MakeVisibleResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ MakeVisibleResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::MakeVisibleResponse(
+ ::fidl::DecodedMessage<MakeVisibleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MakeVisibleResponse::PrimarySize,
+ MakeVisibleResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::MakeVisibleCompleterBase::ReplySuccess() {
+ Coordinator_MakeVisible_Response response;
+
+ Reply(Coordinator_MakeVisible_Result::WithResponse(&response));
+}
+void Coordinator::Interface::MakeVisibleCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_MakeVisible_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::MakeVisibleCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result result) {
+ if (_buffer.capacity() < MakeVisibleResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ MakeVisibleResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::MakeVisibleResponse(
+ ::fidl::DecodedMessage<MakeVisibleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MakeVisibleResponse::PrimarySize,
+ MakeVisibleResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::MakeVisibleCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Coordinator_MakeVisible_Response response;
+
+ Reply(std::move(_buffer), Coordinator_MakeVisible_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::MakeVisibleCompleterBase::Reply(::fidl::DecodedMessage<MakeVisibleResponse> params) {
+ Coordinator::SetTransactionHeaderFor::MakeVisibleResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::BindDeviceCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindDeviceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ BindDeviceResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::BindDeviceResponse(
+ ::fidl::DecodedMessage<BindDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindDeviceResponse::PrimarySize,
+ BindDeviceResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::BindDeviceCompleterBase::ReplySuccess() {
+ Coordinator_BindDevice_Response response;
+
+ Reply(Coordinator_BindDevice_Result::WithResponse(&response));
+}
+void Coordinator::Interface::BindDeviceCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_BindDevice_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::BindDeviceCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result result) {
+ if (_buffer.capacity() < BindDeviceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ BindDeviceResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::BindDeviceResponse(
+ ::fidl::DecodedMessage<BindDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindDeviceResponse::PrimarySize,
+ BindDeviceResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::BindDeviceCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Coordinator_BindDevice_Response response;
+
+ Reply(std::move(_buffer), Coordinator_BindDevice_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::BindDeviceCompleterBase::Reply(::fidl::DecodedMessage<BindDeviceResponse> params) {
+ Coordinator::SetTransactionHeaderFor::BindDeviceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::GetTopologicalPathCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTopologicalPathResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetTopologicalPathResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::GetTopologicalPathResponse(
+ ::fidl::DecodedMessage<GetTopologicalPathResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTopologicalPathResponse::PrimarySize,
+ GetTopologicalPathResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::GetTopologicalPathCompleterBase::ReplySuccess(::fidl::StringView path) {
+ Coordinator_GetTopologicalPath_Response response;
+ response.path = std::move(path);
+
+ Reply(Coordinator_GetTopologicalPath_Result::WithResponse(&response));
+}
+void Coordinator::Interface::GetTopologicalPathCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_GetTopologicalPath_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::GetTopologicalPathCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result result) {
+ if (_buffer.capacity() < GetTopologicalPathResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTopologicalPathResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::GetTopologicalPathResponse(
+ ::fidl::DecodedMessage<GetTopologicalPathResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTopologicalPathResponse::PrimarySize,
+ GetTopologicalPathResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::GetTopologicalPathCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView path) {
+ Coordinator_GetTopologicalPath_Response response;
+ response.path = std::move(path);
+
+ Reply(std::move(_buffer), Coordinator_GetTopologicalPath_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::GetTopologicalPathCompleterBase::Reply(::fidl::DecodedMessage<GetTopologicalPathResponse> params) {
+ Coordinator::SetTransactionHeaderFor::GetTopologicalPathResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::LoadFirmwareCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LoadFirmwareResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ LoadFirmwareResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::LoadFirmwareResponse(
+ ::fidl::DecodedMessage<LoadFirmwareResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LoadFirmwareResponse::PrimarySize,
+ LoadFirmwareResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::LoadFirmwareCompleterBase::ReplySuccess(::zx::vmo vmo, uint64_t size) {
+ Coordinator_LoadFirmware_Response response;
+ response.vmo = std::move(vmo);
+ response.size = std::move(size);
+
+ Reply(Coordinator_LoadFirmware_Result::WithResponse(&response));
+}
+void Coordinator::Interface::LoadFirmwareCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_LoadFirmware_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::LoadFirmwareCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result result) {
+ if (_buffer.capacity() < LoadFirmwareResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ LoadFirmwareResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::LoadFirmwareResponse(
+ ::fidl::DecodedMessage<LoadFirmwareResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LoadFirmwareResponse::PrimarySize,
+ LoadFirmwareResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::LoadFirmwareCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::vmo vmo, uint64_t size) {
+ Coordinator_LoadFirmware_Response response;
+ response.vmo = std::move(vmo);
+ response.size = std::move(size);
+
+ Reply(std::move(_buffer), Coordinator_LoadFirmware_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::LoadFirmwareCompleterBase::Reply(::fidl::DecodedMessage<LoadFirmwareResponse> params) {
+ Coordinator::SetTransactionHeaderFor::LoadFirmwareResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::GetMetadataCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetadataResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetMetadataResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::GetMetadataResponse(
+ ::fidl::DecodedMessage<GetMetadataResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMetadataResponse::PrimarySize,
+ GetMetadataResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::GetMetadataCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> data) {
+ Coordinator_GetMetadata_Response response;
+ response.data = std::move(data);
+
+ Reply(Coordinator_GetMetadata_Result::WithResponse(&response));
+}
+void Coordinator::Interface::GetMetadataCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_GetMetadata_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::GetMetadataCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result result) {
+ if (_buffer.capacity() < GetMetadataResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetMetadataResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::GetMetadataResponse(
+ ::fidl::DecodedMessage<GetMetadataResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMetadataResponse::PrimarySize,
+ GetMetadataResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::GetMetadataCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data) {
+ Coordinator_GetMetadata_Response response;
+ response.data = std::move(data);
+
+ Reply(std::move(_buffer), Coordinator_GetMetadata_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::GetMetadataCompleterBase::Reply(::fidl::DecodedMessage<GetMetadataResponse> params) {
+ Coordinator::SetTransactionHeaderFor::GetMetadataResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::GetMetadataSizeCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetadataSizeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetMetadataSizeResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::GetMetadataSizeResponse(
+ ::fidl::DecodedMessage<GetMetadataSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMetadataSizeResponse::PrimarySize,
+ GetMetadataSizeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::GetMetadataSizeCompleterBase::ReplySuccess(uint64_t size) {
+ Coordinator_GetMetadataSize_Response response;
+ response.size = std::move(size);
+
+ Reply(Coordinator_GetMetadataSize_Result::WithResponse(&response));
+}
+void Coordinator::Interface::GetMetadataSizeCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_GetMetadataSize_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::GetMetadataSizeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result result) {
+ if (_buffer.capacity() < GetMetadataSizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetMetadataSizeResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::GetMetadataSizeResponse(
+ ::fidl::DecodedMessage<GetMetadataSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMetadataSizeResponse::PrimarySize,
+ GetMetadataSizeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::GetMetadataSizeCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t size) {
+ Coordinator_GetMetadataSize_Response response;
+ response.size = std::move(size);
+
+ Reply(std::move(_buffer), Coordinator_GetMetadataSize_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::GetMetadataSizeCompleterBase::Reply(::fidl::DecodedMessage<GetMetadataSizeResponse> params) {
+ Coordinator::SetTransactionHeaderFor::GetMetadataSizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::AddMetadataCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddMetadataResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AddMetadataResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::AddMetadataResponse(
+ ::fidl::DecodedMessage<AddMetadataResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddMetadataResponse::PrimarySize,
+ AddMetadataResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::AddMetadataCompleterBase::ReplySuccess() {
+ Coordinator_AddMetadata_Response response;
+
+ Reply(Coordinator_AddMetadata_Result::WithResponse(&response));
+}
+void Coordinator::Interface::AddMetadataCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_AddMetadata_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::AddMetadataCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result result) {
+ if (_buffer.capacity() < AddMetadataResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AddMetadataResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::AddMetadataResponse(
+ ::fidl::DecodedMessage<AddMetadataResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddMetadataResponse::PrimarySize,
+ AddMetadataResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::AddMetadataCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Coordinator_AddMetadata_Response response;
+
+ Reply(std::move(_buffer), Coordinator_AddMetadata_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::AddMetadataCompleterBase::Reply(::fidl::DecodedMessage<AddMetadataResponse> params) {
+ Coordinator::SetTransactionHeaderFor::AddMetadataResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::PublishMetadataCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PublishMetadataResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ PublishMetadataResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::PublishMetadataResponse(
+ ::fidl::DecodedMessage<PublishMetadataResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ PublishMetadataResponse::PrimarySize,
+ PublishMetadataResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::PublishMetadataCompleterBase::ReplySuccess() {
+ Coordinator_PublishMetadata_Response response;
+
+ Reply(Coordinator_PublishMetadata_Result::WithResponse(&response));
+}
+void Coordinator::Interface::PublishMetadataCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_PublishMetadata_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::PublishMetadataCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result result) {
+ if (_buffer.capacity() < PublishMetadataResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ PublishMetadataResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::PublishMetadataResponse(
+ ::fidl::DecodedMessage<PublishMetadataResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ PublishMetadataResponse::PrimarySize,
+ PublishMetadataResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::PublishMetadataCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Coordinator_PublishMetadata_Response response;
+
+ Reply(std::move(_buffer), Coordinator_PublishMetadata_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::PublishMetadataCompleterBase::Reply(::fidl::DecodedMessage<PublishMetadataResponse> params) {
+ Coordinator::SetTransactionHeaderFor::PublishMetadataResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::AddCompositeDeviceCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddCompositeDeviceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AddCompositeDeviceResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::AddCompositeDeviceResponse(
+ ::fidl::DecodedMessage<AddCompositeDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddCompositeDeviceResponse::PrimarySize,
+ AddCompositeDeviceResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::AddCompositeDeviceCompleterBase::ReplySuccess() {
+ Coordinator_AddCompositeDevice_Response response;
+
+ Reply(Coordinator_AddCompositeDevice_Result::WithResponse(&response));
+}
+void Coordinator::Interface::AddCompositeDeviceCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_AddCompositeDevice_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::AddCompositeDeviceCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result result) {
+ if (_buffer.capacity() < AddCompositeDeviceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AddCompositeDeviceResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::AddCompositeDeviceResponse(
+ ::fidl::DecodedMessage<AddCompositeDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddCompositeDeviceResponse::PrimarySize,
+ AddCompositeDeviceResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::AddCompositeDeviceCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Coordinator_AddCompositeDevice_Response response;
+
+ Reply(std::move(_buffer), Coordinator_AddCompositeDevice_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::AddCompositeDeviceCompleterBase::Reply(::fidl::DecodedMessage<AddCompositeDeviceResponse> params) {
+ Coordinator::SetTransactionHeaderFor::AddCompositeDeviceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::DirectoryWatchCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DirectoryWatchResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DirectoryWatchResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::DirectoryWatchResponse(
+ ::fidl::DecodedMessage<DirectoryWatchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DirectoryWatchResponse::PrimarySize,
+ DirectoryWatchResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::DirectoryWatchCompleterBase::ReplySuccess() {
+ Coordinator_DirectoryWatch_Response response;
+
+ Reply(Coordinator_DirectoryWatch_Result::WithResponse(&response));
+}
+void Coordinator::Interface::DirectoryWatchCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_DirectoryWatch_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::DirectoryWatchCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result result) {
+ if (_buffer.capacity() < DirectoryWatchResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DirectoryWatchResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::DirectoryWatchResponse(
+ ::fidl::DecodedMessage<DirectoryWatchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DirectoryWatchResponse::PrimarySize,
+ DirectoryWatchResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::DirectoryWatchCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Coordinator_DirectoryWatch_Response response;
+
+ Reply(std::move(_buffer), Coordinator_DirectoryWatch_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::DirectoryWatchCompleterBase::Reply(::fidl::DecodedMessage<DirectoryWatchResponse> params) {
+ Coordinator::SetTransactionHeaderFor::DirectoryWatchResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Coordinator::Interface::RunCompatibilityTestsCompleterBase::Reply(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RunCompatibilityTestsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ RunCompatibilityTestsResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::RunCompatibilityTestsResponse(
+ ::fidl::DecodedMessage<RunCompatibilityTestsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RunCompatibilityTestsResponse::PrimarySize,
+ RunCompatibilityTestsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::RunCompatibilityTestsCompleterBase::ReplySuccess() {
+ Coordinator_RunCompatibilityTests_Response response;
+
+ Reply(Coordinator_RunCompatibilityTests_Result::WithResponse(&response));
+}
+void Coordinator::Interface::RunCompatibilityTestsCompleterBase::ReplyError(int32_t error) {
+ Reply(Coordinator_RunCompatibilityTests_Result::WithErr(&error));
+}
+
+void Coordinator::Interface::RunCompatibilityTestsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result result) {
+ if (_buffer.capacity() < RunCompatibilityTestsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RunCompatibilityTestsResponse _response = {};
+ Coordinator::SetTransactionHeaderFor::RunCompatibilityTestsResponse(
+ ::fidl::DecodedMessage<RunCompatibilityTestsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RunCompatibilityTestsResponse::PrimarySize,
+ RunCompatibilityTestsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Coordinator::Interface::RunCompatibilityTestsCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Coordinator_RunCompatibilityTests_Response response;
+
+ Reply(std::move(_buffer), Coordinator_RunCompatibilityTests_Result::WithResponse(&response));
+}
+
+void Coordinator::Interface::RunCompatibilityTestsCompleterBase::Reply(::fidl::DecodedMessage<RunCompatibilityTestsResponse> params) {
+ Coordinator::SetTransactionHeaderFor::RunCompatibilityTestsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Coordinator::SetTransactionHeaderFor::AddDeviceRequest(const ::fidl::DecodedMessage<Coordinator::AddDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_AddDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::AddDeviceResponse(const ::fidl::DecodedMessage<Coordinator::AddDeviceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_AddDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::AddDeviceInvisibleRequest(const ::fidl::DecodedMessage<Coordinator::AddDeviceInvisibleRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_AddDeviceInvisible_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::AddDeviceInvisibleResponse(const ::fidl::DecodedMessage<Coordinator::AddDeviceInvisibleResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_AddDeviceInvisible_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::ScheduleRemoveRequest(const ::fidl::DecodedMessage<Coordinator::ScheduleRemoveRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_ScheduleRemove_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::ScheduleUnbindChildrenRequest(const ::fidl::DecodedMessage<Coordinator::ScheduleUnbindChildrenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_ScheduleUnbindChildren_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::MakeVisibleRequest(const ::fidl::DecodedMessage<Coordinator::MakeVisibleRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_MakeVisible_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::MakeVisibleResponse(const ::fidl::DecodedMessage<Coordinator::MakeVisibleResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_MakeVisible_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::BindDeviceRequest(const ::fidl::DecodedMessage<Coordinator::BindDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_BindDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::BindDeviceResponse(const ::fidl::DecodedMessage<Coordinator::BindDeviceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_BindDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::GetTopologicalPathRequest(const ::fidl::DecodedMessage<Coordinator::GetTopologicalPathRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_GetTopologicalPath_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::GetTopologicalPathResponse(const ::fidl::DecodedMessage<Coordinator::GetTopologicalPathResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_GetTopologicalPath_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::LoadFirmwareRequest(const ::fidl::DecodedMessage<Coordinator::LoadFirmwareRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_LoadFirmware_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::LoadFirmwareResponse(const ::fidl::DecodedMessage<Coordinator::LoadFirmwareResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_LoadFirmware_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::GetMetadataRequest(const ::fidl::DecodedMessage<Coordinator::GetMetadataRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_GetMetadata_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::GetMetadataResponse(const ::fidl::DecodedMessage<Coordinator::GetMetadataResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_GetMetadata_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::GetMetadataSizeRequest(const ::fidl::DecodedMessage<Coordinator::GetMetadataSizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_GetMetadataSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::GetMetadataSizeResponse(const ::fidl::DecodedMessage<Coordinator::GetMetadataSizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_GetMetadataSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::AddMetadataRequest(const ::fidl::DecodedMessage<Coordinator::AddMetadataRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_AddMetadata_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::AddMetadataResponse(const ::fidl::DecodedMessage<Coordinator::AddMetadataResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_AddMetadata_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::PublishMetadataRequest(const ::fidl::DecodedMessage<Coordinator::PublishMetadataRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_PublishMetadata_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::PublishMetadataResponse(const ::fidl::DecodedMessage<Coordinator::PublishMetadataResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_PublishMetadata_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::AddCompositeDeviceRequest(const ::fidl::DecodedMessage<Coordinator::AddCompositeDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_AddCompositeDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::AddCompositeDeviceResponse(const ::fidl::DecodedMessage<Coordinator::AddCompositeDeviceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_AddCompositeDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::DirectoryWatchRequest(const ::fidl::DecodedMessage<Coordinator::DirectoryWatchRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_DirectoryWatch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::DirectoryWatchResponse(const ::fidl::DecodedMessage<Coordinator::DirectoryWatchResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_DirectoryWatch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Coordinator::SetTransactionHeaderFor::RunCompatibilityTestsRequest(const ::fidl::DecodedMessage<Coordinator::RunCompatibilityTestsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_RunCompatibilityTests_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Coordinator::SetTransactionHeaderFor::RunCompatibilityTestsResponse(const ::fidl::DecodedMessage<Coordinator::RunCompatibilityTestsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCoordinator_RunCompatibilityTests_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace manager
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-device-manager/gen/llcpp/include/fuchsia/device/manager/llcpp/fidl.h b/zircon/system/fidl/fuchsia-device-manager/gen/llcpp/include/fuchsia/device/manager/llcpp/fidl.h
new file mode 100644
index 0000000..9debb87
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-device-manager/gen/llcpp/include/fuchsia/device/manager/llcpp/fidl.h
@@ -0,0 +1,6013 @@
+// 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/handle.h>
+#include <lib/zx/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+namespace manager {
+
+enum class SystemPowerState : uint8_t {
+ SYSTEM_POWER_STATE_FULLY_ON = 1u,
+ SYSTEM_POWER_STATE_REBOOT = 2u,
+ SYSTEM_POWER_STATE_REBOOT_BOOTLOADER = 3u,
+ SYSTEM_POWER_STATE_REBOOT_RECOVERY = 4u,
+ SYSTEM_POWER_STATE_POWEROFF = 5u,
+ SYSTEM_POWER_STATE_MEXEC = 6u,
+ SYSTEM_POWER_STATE_SUSPEND_RAM = 7u,
+};
+
+
+class DebugDumper;
+class Administrator;
+class DevhostController;
+struct Coordinator_AddDevice_Response;
+struct Coordinator_AddDevice_Result;
+struct Coordinator_AddDeviceInvisible_Response;
+struct Coordinator_AddDeviceInvisible_Result;
+struct DeviceMetadata;
+struct DeviceController_Unbind_Response;
+struct DeviceController_Unbind_Result;
+struct DeviceController_CompleteRemoval_Response;
+struct DeviceController_CompleteRemoval_Result;
+struct Coordinator_RunCompatibilityTests_Response;
+struct Coordinator_RunCompatibilityTests_Result;
+struct Coordinator_PublishMetadata_Response;
+struct Coordinator_PublishMetadata_Result;
+struct Coordinator_MakeVisible_Response;
+struct Coordinator_MakeVisible_Result;
+struct Coordinator_LoadFirmware_Response;
+struct Coordinator_LoadFirmware_Result;
+struct Coordinator_GetTopologicalPath_Response;
+struct Coordinator_GetTopologicalPath_Result;
+struct Coordinator_GetMetadata_Response;
+struct Coordinator_GetMetadata_Result;
+struct Coordinator_GetMetadataSize_Response;
+struct Coordinator_GetMetadataSize_Result;
+struct Coordinator_DirectoryWatch_Response;
+struct Coordinator_DirectoryWatch_Result;
+struct Coordinator_BindDevice_Response;
+struct Coordinator_BindDevice_Result;
+struct Coordinator_AddMetadata_Response;
+struct Coordinator_AddMetadata_Result;
+struct Coordinator_AddCompositeDevice_Response;
+struct Coordinator_AddCompositeDevice_Result;
+enum class CompatibilityTestStatus : uint32_t {
+ OK = 1u,
+ ERR_BIND_NO_DDKADD = 2u,
+ ERR_BIND_TIMEOUT = 3u,
+ ERR_UNBIND_NO_DDKREMOVE = 4u,
+ ERR_UNBIND_TIMEOUT = 5u,
+ ERR_SUSPEND_DDKREMOVE = 6u,
+ ERR_INTERNAL = 7u,
+};
+
+
+class DeviceController;
+struct BindInstruction;
+struct DeviceComponentPart;
+struct DeviceComponent;
+struct CompositeDeviceDescriptor;
+class AddDeviceConfig final {
+public:
+ constexpr AddDeviceConfig() : value_(0u) {}
+ explicit constexpr AddDeviceConfig(uint32_t value) : value_(value) {}
+ const static AddDeviceConfig ALLOW_MULTI_COMPOSITE;
+ const static AddDeviceConfig mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const AddDeviceConfig& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const AddDeviceConfig& other) const { return value_ != other.value_; }
+ constexpr inline AddDeviceConfig operator~() const;
+ constexpr inline AddDeviceConfig operator|(const AddDeviceConfig& other) const;
+ constexpr inline AddDeviceConfig operator&(const AddDeviceConfig& other) const;
+ constexpr inline AddDeviceConfig operator^(const AddDeviceConfig& other) const;
+ constexpr inline void operator|=(const AddDeviceConfig& other);
+ constexpr inline void operator&=(const AddDeviceConfig& other);
+ constexpr inline void operator^=(const AddDeviceConfig& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::ALLOW_MULTI_COMPOSITE = ::llcpp::fuchsia::device::manager::AddDeviceConfig(1u);
+constexpr const ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::mask = ::llcpp::fuchsia::device::manager::AddDeviceConfig(1u);
+
+constexpr inline ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::operator~() const {
+ return ::llcpp::fuchsia::device::manager::AddDeviceConfig(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::operator|(
+ const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) const {
+ return ::llcpp::fuchsia::device::manager::AddDeviceConfig(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::operator&(
+ const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) const {
+ return ::llcpp::fuchsia::device::manager::AddDeviceConfig(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::device::manager::AddDeviceConfig AddDeviceConfig::operator^(
+ const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) const {
+ return ::llcpp::fuchsia::device::manager::AddDeviceConfig(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void AddDeviceConfig::operator|=(
+ const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void AddDeviceConfig::operator&=(
+ const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void AddDeviceConfig::operator^=(
+ const ::llcpp::fuchsia::device::manager::AddDeviceConfig& other) {
+ this->value_ ^= other.value_;
+}
+
+class Coordinator;
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddDevice_ResultTable;
+
+struct Coordinator_AddDevice_Result {
+ Coordinator_AddDevice_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_AddDevice_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response* val) {
+ Coordinator_AddDevice_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_AddDevice_Result WithErr(int32_t* val) {
+ Coordinator_AddDevice_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddDevice_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddDeviceInvisible_ResultTable;
+
+struct Coordinator_AddDeviceInvisible_Result {
+ Coordinator_AddDeviceInvisible_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_AddDeviceInvisible_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response* val) {
+ Coordinator_AddDeviceInvisible_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_AddDeviceInvisible_Result WithErr(int32_t* val) {
+ Coordinator_AddDeviceInvisible_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddDeviceInvisible_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceController_Unbind_ResultTable;
+
+struct DeviceController_Unbind_Result {
+ DeviceController_Unbind_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static DeviceController_Unbind_Result WithResponse(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response* val) {
+ DeviceController_Unbind_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static DeviceController_Unbind_Result WithErr(int32_t* val) {
+ DeviceController_Unbind_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceController_Unbind_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceController_CompleteRemoval_ResultTable;
+
+struct DeviceController_CompleteRemoval_Result {
+ DeviceController_CompleteRemoval_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static DeviceController_CompleteRemoval_Result WithResponse(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response* val) {
+ DeviceController_CompleteRemoval_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static DeviceController_CompleteRemoval_Result WithErr(int32_t* val) {
+ DeviceController_CompleteRemoval_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceController_CompleteRemoval_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_RunCompatibilityTests_ResultTable;
+
+struct Coordinator_RunCompatibilityTests_Result {
+ Coordinator_RunCompatibilityTests_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_RunCompatibilityTests_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response* val) {
+ Coordinator_RunCompatibilityTests_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_RunCompatibilityTests_Result WithErr(int32_t* val) {
+ Coordinator_RunCompatibilityTests_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_RunCompatibilityTests_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_PublishMetadata_ResultTable;
+
+struct Coordinator_PublishMetadata_Result {
+ Coordinator_PublishMetadata_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_PublishMetadata_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response* val) {
+ Coordinator_PublishMetadata_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_PublishMetadata_Result WithErr(int32_t* val) {
+ Coordinator_PublishMetadata_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_PublishMetadata_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_MakeVisible_ResultTable;
+
+struct Coordinator_MakeVisible_Result {
+ Coordinator_MakeVisible_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_MakeVisible_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response* val) {
+ Coordinator_MakeVisible_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_MakeVisible_Result WithErr(int32_t* val) {
+ Coordinator_MakeVisible_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_MakeVisible_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_LoadFirmware_ResultTable;
+
+struct Coordinator_LoadFirmware_Result {
+ Coordinator_LoadFirmware_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_LoadFirmware_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response* val) {
+ Coordinator_LoadFirmware_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_LoadFirmware_Result WithErr(int32_t* val) {
+ Coordinator_LoadFirmware_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_LoadFirmware_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_GetTopologicalPath_ResultTable;
+
+struct Coordinator_GetTopologicalPath_Result {
+ Coordinator_GetTopologicalPath_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_GetTopologicalPath_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response* val) {
+ Coordinator_GetTopologicalPath_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_GetTopologicalPath_Result WithErr(int32_t* val) {
+ Coordinator_GetTopologicalPath_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_GetTopologicalPath_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 1040;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_GetMetadata_ResultTable;
+
+struct Coordinator_GetMetadata_Result {
+ Coordinator_GetMetadata_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_GetMetadata_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response* val) {
+ Coordinator_GetMetadata_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_GetMetadata_Result WithErr(int32_t* val) {
+ Coordinator_GetMetadata_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_GetMetadata_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8208;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_GetMetadataSize_ResultTable;
+
+struct Coordinator_GetMetadataSize_Result {
+ Coordinator_GetMetadataSize_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_GetMetadataSize_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response* val) {
+ Coordinator_GetMetadataSize_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_GetMetadataSize_Result WithErr(int32_t* val) {
+ Coordinator_GetMetadataSize_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_GetMetadataSize_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_DirectoryWatch_ResultTable;
+
+struct Coordinator_DirectoryWatch_Result {
+ Coordinator_DirectoryWatch_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_DirectoryWatch_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response* val) {
+ Coordinator_DirectoryWatch_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_DirectoryWatch_Result WithErr(int32_t* val) {
+ Coordinator_DirectoryWatch_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_DirectoryWatch_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_BindDevice_ResultTable;
+
+struct Coordinator_BindDevice_Result {
+ Coordinator_BindDevice_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_BindDevice_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response* val) {
+ Coordinator_BindDevice_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_BindDevice_Result WithErr(int32_t* val) {
+ Coordinator_BindDevice_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_BindDevice_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddMetadata_ResultTable;
+
+struct Coordinator_AddMetadata_Result {
+ Coordinator_AddMetadata_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_AddMetadata_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response* val) {
+ Coordinator_AddMetadata_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_AddMetadata_Result WithErr(int32_t* val) {
+ Coordinator_AddMetadata_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddMetadata_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddCompositeDevice_ResultTable;
+
+struct Coordinator_AddCompositeDevice_Result {
+ Coordinator_AddCompositeDevice_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Coordinator_AddCompositeDevice_Result WithResponse(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response* val) {
+ Coordinator_AddCompositeDevice_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Coordinator_AddCompositeDevice_Result WithErr(int32_t* val) {
+ Coordinator_AddCompositeDevice_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddCompositeDevice_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpTreeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpTreeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpDriversRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpDriversResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesResponseTable;
+
+// Dumps text debug information.
+//
+// All methods dump ascii text into a VMO, this allows the caller the flexibility to decide
+// how much data they want. Use the returned `written` value to read the data, no string
+// termination is guaranteed.
+class DebugDumper final {
+ DebugDumper() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.device.manager.DebugDumper";
+
+ struct DumpTreeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint64_t written;
+ uint64_t available;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpTreeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ 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 DumpTreeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo output;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpTreeRequestTable;
+ 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 = DumpTreeResponse;
+ };
+
+ struct DumpDriversResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint64_t written;
+ uint64_t available;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpDriversResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ 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 DumpDriversRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo output;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpDriversRequestTable;
+ 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 = DumpDriversResponse;
+ };
+
+ struct DumpBindingPropertiesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint64_t written;
+ uint64_t available;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ 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 DumpBindingPropertiesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo output;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DebugDumperDumpBindingPropertiesRequestTable;
+ 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 = DumpBindingPropertiesResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class DumpTree_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ DumpTree_Impl(::zx::unowned_channel _client_end, ::zx::vmo output);
+ ~DumpTree_Impl() = default;
+ DumpTree_Impl(DumpTree_Impl&& other) = default;
+ DumpTree_Impl& operator=(DumpTree_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 DumpDrivers_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ DumpDrivers_Impl(::zx::unowned_channel _client_end, ::zx::vmo output);
+ ~DumpDrivers_Impl() = default;
+ DumpDrivers_Impl(DumpDrivers_Impl&& other) = default;
+ DumpDrivers_Impl& operator=(DumpDrivers_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 DumpBindingProperties_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ DumpBindingProperties_Impl(::zx::unowned_channel _client_end, ::zx::vmo output);
+ ~DumpBindingProperties_Impl() = default;
+ DumpBindingProperties_Impl(DumpBindingProperties_Impl&& other) = default;
+ DumpBindingProperties_Impl& operator=(DumpBindingProperties_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 DumpTree = DumpTree_Impl<DumpTreeResponse>;
+ using DumpDrivers = DumpDrivers_Impl<DumpDriversResponse>;
+ using DumpBindingProperties = DumpBindingProperties_Impl<DumpBindingPropertiesResponse>;
+ };
+
+ // 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 DumpTree_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ DumpTree_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
+ ~DumpTree_Impl() = default;
+ DumpTree_Impl(DumpTree_Impl&& other) = default;
+ DumpTree_Impl& operator=(DumpTree_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 DumpDrivers_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ DumpDrivers_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
+ ~DumpDrivers_Impl() = default;
+ DumpDrivers_Impl(DumpDrivers_Impl&& other) = default;
+ DumpDrivers_Impl& operator=(DumpDrivers_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 DumpBindingProperties_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ DumpBindingProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
+ ~DumpBindingProperties_Impl() = default;
+ DumpBindingProperties_Impl(DumpBindingProperties_Impl&& other) = default;
+ DumpBindingProperties_Impl& operator=(DumpBindingProperties_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 DumpTree = DumpTree_Impl<DumpTreeResponse>;
+ using DumpDrivers = DumpDrivers_Impl<DumpDriversResponse>;
+ using DumpBindingProperties = DumpBindingProperties_Impl<DumpBindingPropertiesResponse>;
+ };
+
+ 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_; }
+
+ // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DumpTree DumpTree(::zx::vmo output);
+
+ // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DumpTree DumpTree(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
+
+ // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DumpDrivers DumpDrivers(::zx::vmo output);
+
+ // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DumpDrivers DumpDrivers(::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
+
+ // Print all devices and their binding properties into `output`, returns bytes `written`
+ // and bytes `available` to write.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DumpBindingProperties DumpBindingProperties(::zx::vmo output);
+
+ // Print all devices and their binding properties into `output`, returns bytes `written`
+ // and bytes `available` to write.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DumpBindingProperties DumpBindingProperties(::fidl::BytePart _request_buffer, ::zx::vmo output, ::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:
+
+ // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DumpTree DumpTree(::zx::unowned_channel _client_end, ::zx::vmo output);
+
+ // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DumpTree DumpTree(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
+
+ // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DumpDrivers DumpDrivers(::zx::unowned_channel _client_end, ::zx::vmo output);
+
+ // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DumpDrivers DumpDrivers(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::fidl::BytePart _response_buffer);
+
+ // Print all devices and their binding properties into `output`, returns bytes `written`
+ // and bytes `available` to write.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DumpBindingProperties DumpBindingProperties(::zx::unowned_channel _client_end, ::zx::vmo output);
+
+ // Print all devices and their binding properties into `output`, returns bytes `written`
+ // and bytes `available` to write.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DumpBindingProperties DumpBindingProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo output, ::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:
+
+ // Print device tree into `output`, returns bytes `written` and bytes `available` to write.
+ static ::fidl::DecodeResult<DumpTreeResponse> DumpTree(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpTreeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Print information about all drivers into `output`, returns bytes `written` and bytes `available` to write.
+ static ::fidl::DecodeResult<DumpDriversResponse> DumpDrivers(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpDriversRequest> params, ::fidl::BytePart response_buffer);
+
+ // Print all devices and their binding properties into `output`, returns bytes `written`
+ // and bytes `available` to write.
+ static ::fidl::DecodeResult<DumpBindingPropertiesResponse> DumpBindingProperties(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DumpBindingPropertiesRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DebugDumper;
+ using _Base = ::fidl::CompleterBase;
+
+ class DumpTreeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint64_t written, uint64_t available);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available);
+ void Reply(::fidl::DecodedMessage<DumpTreeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DumpTreeCompleter = ::fidl::Completer<DumpTreeCompleterBase>;
+
+ virtual void DumpTree(::zx::vmo output, DumpTreeCompleter::Sync _completer) = 0;
+
+ class DumpDriversCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint64_t written, uint64_t available);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available);
+ void Reply(::fidl::DecodedMessage<DumpDriversResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DumpDriversCompleter = ::fidl::Completer<DumpDriversCompleterBase>;
+
+ virtual void DumpDrivers(::zx::vmo output, DumpDriversCompleter::Sync _completer) = 0;
+
+ class DumpBindingPropertiesCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint64_t written, uint64_t available);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint64_t written, uint64_t available);
+ void Reply(::fidl::DecodedMessage<DumpBindingPropertiesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DumpBindingPropertiesCompleter = ::fidl::Completer<DumpBindingPropertiesCompleterBase>;
+
+ virtual void DumpBindingProperties(::zx::vmo output, DumpBindingPropertiesCompleter::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 DumpTreeRequest(const ::fidl::DecodedMessage<DebugDumper::DumpTreeRequest>& _msg);
+ static void DumpTreeResponse(const ::fidl::DecodedMessage<DebugDumper::DumpTreeResponse>& _msg);
+ static void DumpDriversRequest(const ::fidl::DecodedMessage<DebugDumper::DumpDriversRequest>& _msg);
+ static void DumpDriversResponse(const ::fidl::DecodedMessage<DebugDumper::DumpDriversResponse>& _msg);
+ static void DumpBindingPropertiesRequest(const ::fidl::DecodedMessage<DebugDumper::DumpBindingPropertiesRequest>& _msg);
+ static void DumpBindingPropertiesResponse(const ::fidl::DecodedMessage<DebugDumper::DumpBindingPropertiesResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_AdministratorSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_AdministratorSuspendResponseTable;
+
+// Provides administration services for the device manager service and the device tree it controls.
+class Administrator final {
+ Administrator() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.device.manager.Administrator";
+
+ struct SuspendResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_AdministratorSuspendResponseTable;
+ 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 SuspendRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_AdministratorSuspendRequestTable;
+ 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 = SuspendResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Suspend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Suspend_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~Suspend_Impl() = default;
+ Suspend_Impl(Suspend_Impl&& other) = default;
+ Suspend_Impl& operator=(Suspend_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 Suspend = Suspend_Impl<SuspendResponse>;
+ };
+
+ // 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 Suspend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~Suspend_Impl() = default;
+ Suspend_Impl(Suspend_Impl&& other) = default;
+ Suspend_Impl& operator=(Suspend_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 Suspend = Suspend_Impl<SuspendResponse>;
+ };
+
+ 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_; }
+
+ // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
+ // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Suspend Suspend(uint32_t flags);
+
+ // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
+ // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Suspend Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::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:
+
+ // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
+ // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Suspend Suspend(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
+ // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Suspend Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::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:
+
+ // Ask all devices to enter the suspend state indicated by `flags`. Flags should be some
+ // combination of `DEVICE_SUSPEND_FLAG_*` from the DDK.
+ static ::fidl::DecodeResult<SuspendResponse> Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Administrator;
+ using _Base = ::fidl::CompleterBase;
+
+ class SuspendCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SuspendResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SuspendCompleter = ::fidl::Completer<SuspendCompleterBase>;
+
+ virtual void Suspend(uint32_t flags, SuspendCompleter::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 SuspendRequest(const ::fidl::DecodedMessage<Administrator::SuspendRequest>& _msg);
+ static void SuspendResponse(const ::fidl::DecodedMessage<Administrator::SuspendResponse>& _msg);
+ };
+};
+
+constexpr uint32_t SUSPEND_FLAG_SUSPEND_RAM = 3705406464u;
+
+constexpr uint32_t SUSPEND_FLAG_REBOOT_RECOVERY = 3705405698u;
+
+constexpr uint32_t SUSPEND_FLAG_REBOOT_BOOTLOADER = 3705405697u;
+
+// All available suspend flags
+constexpr uint32_t SUSPEND_FLAG_REBOOT = 3705405696u;
+
+constexpr uint32_t SUSPEND_FLAG_POWEROFF = 3705405952u;
+
+constexpr uint32_t SUSPEND_FLAG_MEXEC = 3705406208u;
+
+// Maximum number of properties that can be attached to a device
+constexpr uint32_t PROPERTIES_MAX = 256u;
+
+// Maximum number of metadata that can be added to a device
+constexpr uint32_t METADATA_MAX = 32u;
+
+// Maximum number of bytes in a metadata payload
+constexpr uint32_t METADATA_BYTES_MAX = 8192u;
+
+constexpr uint32_t MAX_SYSTEM_POWER_STATES = 7u;
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateDeviceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceResponseTable;
+
+// Protocol for controlling a devhost process from the devcoordinator
+class DevhostController final {
+ DevhostController() = delete;
+ public:
+
+ struct CreateDeviceStubRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel coordinator_rpc;
+ ::zx::channel device_controller_rpc;
+ uint32_t protocol_id;
+ uint64_t local_device_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DevhostControllerCreateDeviceStubRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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;
+ };
+
+ struct CreateDeviceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel coordinator_rpc;
+ ::zx::channel device_controller_rpc;
+ ::fidl::StringView driver_path;
+ ::zx::vmo driver;
+ ::zx::handle parent_proxy;
+ ::fidl::StringView proxy_args;
+ uint64_t local_device_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DevhostControllerCreateDeviceRequestTable;
+ static constexpr uint32_t MaxNumHandles = 4;
+ static constexpr uint32_t PrimarySize = 72;
+ static constexpr uint32_t MaxOutOfLine = 2048;
+ static constexpr uint32_t AltPrimarySize = 72;
+ static constexpr uint32_t AltMaxOutOfLine = 2048;
+ 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;
+ };
+
+ struct CreateCompositeDeviceResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceResponseTable;
+ 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 CreateCompositeDeviceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel coordinator_rpc;
+ ::zx::channel device_controller_rpc;
+ ::fidl::VectorView<uint64_t> components;
+ ::fidl::StringView name;
+ uint64_t local_device_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DevhostControllerCreateCompositeDeviceRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 64;
+ static constexpr uint32_t MaxOutOfLine = 160;
+ static constexpr uint32_t AltPrimarySize = 64;
+ static constexpr uint32_t AltMaxOutOfLine = 160;
+ 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 = CreateCompositeDeviceResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class CreateDeviceStub_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CreateDeviceStub_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);
+ ~CreateDeviceStub_Impl() = default;
+ CreateDeviceStub_Impl(CreateDeviceStub_Impl&& other) = default;
+ CreateDeviceStub_Impl& operator=(CreateDeviceStub_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class CreateDevice_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CreateDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);
+ ~CreateDevice_Impl() = default;
+ CreateDevice_Impl(CreateDevice_Impl&& other) = default;
+ CreateDevice_Impl& operator=(CreateDevice_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class CreateCompositeDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CreateCompositeDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id);
+ ~CreateCompositeDevice_Impl() = default;
+ CreateCompositeDevice_Impl(CreateCompositeDevice_Impl&& other) = default;
+ CreateCompositeDevice_Impl& operator=(CreateCompositeDevice_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 CreateDeviceStub = CreateDeviceStub_Impl;
+ using CreateDevice = CreateDevice_Impl;
+ using CreateCompositeDevice = CreateCompositeDevice_Impl<CreateCompositeDeviceResponse>;
+ };
+
+ // 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:
+ class CreateDeviceStub_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CreateDeviceStub_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);
+ ~CreateDeviceStub_Impl() = default;
+ CreateDeviceStub_Impl(CreateDeviceStub_Impl&& other) = default;
+ CreateDeviceStub_Impl& operator=(CreateDeviceStub_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class CreateDevice_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CreateDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);
+ ~CreateDevice_Impl() = default;
+ CreateDevice_Impl(CreateDevice_Impl&& other) = default;
+ CreateDevice_Impl& operator=(CreateDevice_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class CreateCompositeDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CreateCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::fidl::BytePart _response_buffer);
+ ~CreateCompositeDevice_Impl() = default;
+ CreateCompositeDevice_Impl(CreateCompositeDevice_Impl&& other) = default;
+ CreateCompositeDevice_Impl& operator=(CreateCompositeDevice_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 CreateDeviceStub = CreateDeviceStub_Impl;
+ using CreateDevice = CreateDevice_Impl;
+ using CreateCompositeDevice = CreateCompositeDevice_Impl<CreateCompositeDeviceResponse>;
+ };
+
+ 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_; }
+
+ // Create a device in the devhost that only implements the device protocol
+ // and claims to support the given `protocol_id`. This device will communicate
+ // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateDeviceStub CreateDeviceStub(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);
+
+ // Create a device in the devhost that only implements the device protocol
+ // and claims to support the given `protocol_id`. This device will communicate
+ // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateDeviceStub CreateDeviceStub(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);
+
+ // Create a device in the devhost representing the shadowed half of device
+ // in another devhost. This new device will communicate with the devcoordinator
+ // via `rpc`, and with its other half via `parent_proxy`.
+ //
+ // The new device will have the given driver responsible for running its half
+ // of the driver's cross-process protocol. It's create() method will be invoked,
+ // giving it access to `parent_proxy` and `proxy_args`.
+ //
+ // parent_proxy, if present, will usually be a channel to the upper half of
+ // a shadowed device. The one exception is when this method is used
+ // to create the Platform Bus, in which case it will be a channel to a
+ // fuchsia.boot.Items protocol.
+ //
+ // `local_device_id` will be a unique value within the device's devhost
+ // Request is heap-allocated.
+ ResultOf::CreateDevice CreateDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);
+
+ // Create a device in the devhost representing the shadowed half of device
+ // in another devhost. This new device will communicate with the devcoordinator
+ // via `rpc`, and with its other half via `parent_proxy`.
+ //
+ // The new device will have the given driver responsible for running its half
+ // of the driver's cross-process protocol. It's create() method will be invoked,
+ // giving it access to `parent_proxy` and `proxy_args`.
+ //
+ // parent_proxy, if present, will usually be a channel to the upper half of
+ // a shadowed device. The one exception is when this method is used
+ // to create the Platform Bus, in which case it will be a channel to a
+ // fuchsia.boot.Items protocol.
+ //
+ // `local_device_id` will be a unique value within the device's devhost
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateDevice CreateDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);
+
+ // Introduce a composite device that has the given name and properties.
+ // `components` will be a list of all of the composite's components,
+ // described using devhost local device ids. The order of the components
+ // will match the original composite creation request. The new device will
+ // communicate with devcoordinator via `rpc`.
+ //
+ // `local_device_id` will be a unique value within the device's devhost, identifying
+ // the resulting composite device.
+ // Allocates 248 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateCompositeDevice CreateCompositeDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id);
+
+ // Introduce a composite device that has the given name and properties.
+ // `components` will be a list of all of the composite's components,
+ // described using devhost local device ids. The order of the components
+ // will match the original composite creation request. The new device will
+ // communicate with devcoordinator via `rpc`.
+ //
+ // `local_device_id` will be a unique value within the device's devhost, identifying
+ // the resulting composite device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateCompositeDevice CreateCompositeDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::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:
+
+ // Create a device in the devhost that only implements the device protocol
+ // and claims to support the given `protocol_id`. This device will communicate
+ // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateDeviceStub CreateDeviceStub(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);
+
+ // Create a device in the devhost that only implements the device protocol
+ // and claims to support the given `protocol_id`. This device will communicate
+ // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateDeviceStub CreateDeviceStub(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id);
+
+ // Create a device in the devhost representing the shadowed half of device
+ // in another devhost. This new device will communicate with the devcoordinator
+ // via `rpc`, and with its other half via `parent_proxy`.
+ //
+ // The new device will have the given driver responsible for running its half
+ // of the driver's cross-process protocol. It's create() method will be invoked,
+ // giving it access to `parent_proxy` and `proxy_args`.
+ //
+ // parent_proxy, if present, will usually be a channel to the upper half of
+ // a shadowed device. The one exception is when this method is used
+ // to create the Platform Bus, in which case it will be a channel to a
+ // fuchsia.boot.Items protocol.
+ //
+ // `local_device_id` will be a unique value within the device's devhost
+ // Request is heap-allocated.
+ static ResultOf::CreateDevice CreateDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);
+
+ // Create a device in the devhost representing the shadowed half of device
+ // in another devhost. This new device will communicate with the devcoordinator
+ // via `rpc`, and with its other half via `parent_proxy`.
+ //
+ // The new device will have the given driver responsible for running its half
+ // of the driver's cross-process protocol. It's create() method will be invoked,
+ // giving it access to `parent_proxy` and `proxy_args`.
+ //
+ // parent_proxy, if present, will usually be a channel to the upper half of
+ // a shadowed device. The one exception is when this method is used
+ // to create the Platform Bus, in which case it will be a channel to a
+ // fuchsia.boot.Items protocol.
+ //
+ // `local_device_id` will be a unique value within the device's devhost
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateDevice CreateDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id);
+
+ // Introduce a composite device that has the given name and properties.
+ // `components` will be a list of all of the composite's components,
+ // described using devhost local device ids. The order of the components
+ // will match the original composite creation request. The new device will
+ // communicate with devcoordinator via `rpc`.
+ //
+ // `local_device_id` will be a unique value within the device's devhost, identifying
+ // the resulting composite device.
+ // Allocates 248 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateCompositeDevice CreateCompositeDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id);
+
+ // Introduce a composite device that has the given name and properties.
+ // `components` will be a list of all of the composite's components,
+ // described using devhost local device ids. The order of the components
+ // will match the original composite creation request. The new device will
+ // communicate with devcoordinator via `rpc`.
+ //
+ // `local_device_id` will be a unique value within the device's devhost, identifying
+ // the resulting composite device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateCompositeDevice CreateCompositeDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, ::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:
+
+ // Create a device in the devhost that only implements the device protocol
+ // and claims to support the given `protocol_id`. This device will communicate
+ // with the devcoordinator via `coordinator`. Implements DeviceController on device_controller_rpc
+ static ::fidl::internal::StatusAndError CreateDeviceStub(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceStubRequest> params);
+
+ // Create a device in the devhost representing the shadowed half of device
+ // in another devhost. This new device will communicate with the devcoordinator
+ // via `rpc`, and with its other half via `parent_proxy`.
+ //
+ // The new device will have the given driver responsible for running its half
+ // of the driver's cross-process protocol. It's create() method will be invoked,
+ // giving it access to `parent_proxy` and `proxy_args`.
+ //
+ // parent_proxy, if present, will usually be a channel to the upper half of
+ // a shadowed device. The one exception is when this method is used
+ // to create the Platform Bus, in which case it will be a channel to a
+ // fuchsia.boot.Items protocol.
+ //
+ // `local_device_id` will be a unique value within the device's devhost
+ static ::fidl::internal::StatusAndError CreateDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateDeviceRequest> params);
+
+ // Introduce a composite device that has the given name and properties.
+ // `components` will be a list of all of the composite's components,
+ // described using devhost local device ids. The order of the components
+ // will match the original composite creation request. The new device will
+ // communicate with devcoordinator via `rpc`.
+ //
+ // `local_device_id` will be a unique value within the device's devhost, identifying
+ // the resulting composite device.
+ static ::fidl::DecodeResult<CreateCompositeDeviceResponse> CreateCompositeDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateCompositeDeviceRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DevhostController;
+ using _Base = ::fidl::CompleterBase;
+
+ using CreateDeviceStubCompleter = ::fidl::Completer<>;
+
+ virtual void CreateDeviceStub(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, uint32_t protocol_id, uint64_t local_device_id, CreateDeviceStubCompleter::Sync _completer) = 0;
+
+ using CreateDeviceCompleter = ::fidl::Completer<>;
+
+ virtual void CreateDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::StringView driver_path, ::zx::vmo driver, ::zx::handle parent_proxy, ::fidl::StringView proxy_args, uint64_t local_device_id, CreateDeviceCompleter::Sync _completer) = 0;
+
+ class CreateCompositeDeviceCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<CreateCompositeDeviceResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CreateCompositeDeviceCompleter = ::fidl::Completer<CreateCompositeDeviceCompleterBase>;
+
+ virtual void CreateCompositeDevice(::zx::channel coordinator_rpc, ::zx::channel device_controller_rpc, ::fidl::VectorView<uint64_t> components, ::fidl::StringView name, uint64_t local_device_id, CreateCompositeDeviceCompleter::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 CreateDeviceStubRequest(const ::fidl::DecodedMessage<DevhostController::CreateDeviceStubRequest>& _msg);
+ static void CreateDeviceRequest(const ::fidl::DecodedMessage<DevhostController::CreateDeviceRequest>& _msg);
+ static void CreateCompositeDeviceRequest(const ::fidl::DecodedMessage<DevhostController::CreateCompositeDeviceRequest>& _msg);
+ static void CreateCompositeDeviceResponse(const ::fidl::DecodedMessage<DevhostController::CreateCompositeDeviceResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddDevice_ResponseTable;
+
+struct Coordinator_AddDevice_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddDevice_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t local_device_id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddDeviceInvisible_ResponseTable;
+
+struct Coordinator_AddDeviceInvisible_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddDeviceInvisible_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t local_device_id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceMetadataTable;
+
+// Metadata that can be added to a device
+struct DeviceMetadata {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceMetadataTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr bool HasPointer = true;
+
+ uint32_t key = {};
+
+ ::fidl::VectorView<uint8_t> data = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceController_Unbind_ResponseTable;
+
+struct DeviceController_Unbind_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceController_Unbind_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceController_CompleteRemoval_ResponseTable;
+
+struct DeviceController_CompleteRemoval_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceController_CompleteRemoval_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+// Maximum number of bytes in a path
+constexpr uint32_t DEVICE_PATH_MAX = 1024u;
+
+// This definition must match `ZX_DEVICE_NAME_MAX` and is checked by a static assert.
+constexpr uint32_t DEVICE_NAME_MAX = 31u;
+
+// Maximum instructions in a match program
+constexpr uint32_t DEVICE_COMPONENT_PART_INSTRUCTIONS_MAX = 32u;
+
+// Maximum number of parts that a composite device component can have
+constexpr uint32_t DEVICE_COMPONENT_PARTS_MAX = 16u;
+
+// Maximum number of bytes in a device arguments string.
+constexpr uint32_t DEVICE_ARGS_MAX = 1024u;
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_RunCompatibilityTests_ResponseTable;
+
+struct Coordinator_RunCompatibilityTests_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_RunCompatibilityTests_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_PublishMetadata_ResponseTable;
+
+struct Coordinator_PublishMetadata_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_PublishMetadata_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_MakeVisible_ResponseTable;
+
+struct Coordinator_MakeVisible_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_MakeVisible_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_LoadFirmware_ResponseTable;
+
+struct Coordinator_LoadFirmware_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_LoadFirmware_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::vmo vmo = {};
+
+ uint64_t size = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_GetTopologicalPath_ResponseTable;
+
+struct Coordinator_GetTopologicalPath_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_GetTopologicalPath_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::StringView path = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_GetMetadata_ResponseTable;
+
+struct Coordinator_GetMetadata_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_GetMetadata_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint8_t> data = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_GetMetadataSize_ResponseTable;
+
+struct Coordinator_GetMetadataSize_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_GetMetadataSize_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t size = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_DirectoryWatch_ResponseTable;
+
+struct Coordinator_DirectoryWatch_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_DirectoryWatch_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_BindDevice_ResponseTable;
+
+struct Coordinator_BindDevice_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_BindDevice_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddMetadata_ResponseTable;
+
+struct Coordinator_AddMetadata_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddMetadata_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_Coordinator_AddCompositeDevice_ResponseTable;
+
+struct Coordinator_AddCompositeDevice_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_Coordinator_AddCompositeDevice_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerBindDriverRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerBindDriverResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerConnectProxyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerConnectProxyResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerInitRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerInitResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerUnbindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerUnbindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteRemovalRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteRemovalResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerSuspendResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerResumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerResumeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsResponseTable;
+
+// Protocol for controlling devices in a devhost process from the devcoordinator
+class DeviceController final {
+ DeviceController() = delete;
+ public:
+
+ struct BindDriverResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::channel test_output;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerBindDriverResponseTable;
+ 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;
+ };
+ struct BindDriverRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView driver_path;
+ ::zx::vmo driver;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerBindDriverRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = BindDriverResponse;
+ };
+
+ struct ConnectProxyRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel shadow;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerConnectProxyRequestTable;
+ 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;
+ };
+
+ struct InitResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerInitResponseTable;
+ 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 InitRequest = ::fidl::AnyZeroArgMessage;
+
+ struct UnbindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerUnbindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using UnbindRequest = ::fidl::AnyZeroArgMessage;
+
+ struct CompleteRemovalResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerCompleteRemovalResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using CompleteRemovalRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SuspendResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerSuspendResponseTable;
+ 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 SuspendRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerSuspendRequestTable;
+ 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 = SuspendResponse;
+ };
+
+ struct ResumeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerResumeResponseTable;
+ 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 ResumeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t target_system_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerResumeRequestTable;
+ 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 = ResumeResponse;
+ };
+
+ struct CompleteCompatibilityTestsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceControllerCompleteCompatibilityTestsRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class BindDriver_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ BindDriver_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver);
+ ~BindDriver_Impl() = default;
+ BindDriver_Impl(BindDriver_Impl&& other) = default;
+ BindDriver_Impl& operator=(BindDriver_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ConnectProxy_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ConnectProxy_Impl(::zx::unowned_channel _client_end, ::zx::channel shadow);
+ ~ConnectProxy_Impl() = default;
+ ConnectProxy_Impl(ConnectProxy_Impl&& other) = default;
+ ConnectProxy_Impl& operator=(ConnectProxy_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Init_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Init_Impl(::zx::unowned_channel _client_end);
+ ~Init_Impl() = default;
+ Init_Impl(Init_Impl&& other) = default;
+ Init_Impl& operator=(Init_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 Unbind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Unbind_Impl(::zx::unowned_channel _client_end);
+ ~Unbind_Impl() = default;
+ Unbind_Impl(Unbind_Impl&& other) = default;
+ Unbind_Impl& operator=(Unbind_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 CompleteRemoval_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CompleteRemoval_Impl(::zx::unowned_channel _client_end);
+ ~CompleteRemoval_Impl() = default;
+ CompleteRemoval_Impl(CompleteRemoval_Impl&& other) = default;
+ CompleteRemoval_Impl& operator=(CompleteRemoval_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 Suspend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Suspend_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~Suspend_Impl() = default;
+ Suspend_Impl(Suspend_Impl&& other) = default;
+ Suspend_Impl& operator=(Suspend_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 Resume_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Resume_Impl(::zx::unowned_channel _client_end, uint32_t target_system_state);
+ ~Resume_Impl() = default;
+ Resume_Impl(Resume_Impl&& other) = default;
+ Resume_Impl& operator=(Resume_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class CompleteCompatibilityTests_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CompleteCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);
+ ~CompleteCompatibilityTests_Impl() = default;
+ CompleteCompatibilityTests_Impl(CompleteCompatibilityTests_Impl&& other) = default;
+ CompleteCompatibilityTests_Impl& operator=(CompleteCompatibilityTests_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using BindDriver = BindDriver_Impl<BindDriverResponse>;
+ using ConnectProxy = ConnectProxy_Impl;
+ using Init = Init_Impl<InitResponse>;
+ using Unbind = Unbind_Impl<UnbindResponse>;
+ using CompleteRemoval = CompleteRemoval_Impl<CompleteRemovalResponse>;
+ using Suspend = Suspend_Impl<SuspendResponse>;
+ using Resume = Resume_Impl<ResumeResponse>;
+ using CompleteCompatibilityTests = CompleteCompatibilityTests_Impl;
+ };
+
+ // 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 BindDriver_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ BindDriver_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer);
+ ~BindDriver_Impl() = default;
+ BindDriver_Impl(BindDriver_Impl&& other) = default;
+ BindDriver_Impl& operator=(BindDriver_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ConnectProxy_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ConnectProxy_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow);
+ ~ConnectProxy_Impl() = default;
+ ConnectProxy_Impl(ConnectProxy_Impl&& other) = default;
+ ConnectProxy_Impl& operator=(ConnectProxy_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Init_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Init_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Init_Impl() = default;
+ Init_Impl(Init_Impl&& other) = default;
+ Init_Impl& operator=(Init_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 Unbind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Unbind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Unbind_Impl() = default;
+ Unbind_Impl(Unbind_Impl&& other) = default;
+ Unbind_Impl& operator=(Unbind_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 CompleteRemoval_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CompleteRemoval_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~CompleteRemoval_Impl() = default;
+ CompleteRemoval_Impl(CompleteRemoval_Impl&& other) = default;
+ CompleteRemoval_Impl& operator=(CompleteRemoval_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 Suspend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~Suspend_Impl() = default;
+ Suspend_Impl(Suspend_Impl&& other) = default;
+ Suspend_Impl& operator=(Suspend_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 Resume_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Resume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer);
+ ~Resume_Impl() = default;
+ Resume_Impl(Resume_Impl&& other) = default;
+ Resume_Impl& operator=(Resume_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class CompleteCompatibilityTests_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CompleteCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);
+ ~CompleteCompatibilityTests_Impl() = default;
+ CompleteCompatibilityTests_Impl(CompleteCompatibilityTests_Impl&& other) = default;
+ CompleteCompatibilityTests_Impl& operator=(CompleteCompatibilityTests_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using BindDriver = BindDriver_Impl<BindDriverResponse>;
+ using ConnectProxy = ConnectProxy_Impl;
+ using Init = Init_Impl<InitResponse>;
+ using Unbind = Unbind_Impl<UnbindResponse>;
+ using CompleteRemoval = CompleteRemoval_Impl<CompleteRemovalResponse>;
+ using Suspend = Suspend_Impl<SuspendResponse>;
+ using Resume = Resume_Impl<ResumeResponse>;
+ using CompleteCompatibilityTests = CompleteCompatibilityTests_Impl;
+ };
+
+ 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_; }
+
+ // Bind the requested driver to this device. `driver_path` is informational,
+ // but all calls to BindDriver/CreateDevice should use the same `driver_path`
+ // each time they use a `driver` VMO with the same contents. Returns a `status`
+ // and optionally a channel to the driver's test output. `test_output` will be
+ // not present unless the driver is configured to run its run_unit_tests hook, in
+ // which case the other end of the channel will have been passed to the driver.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::BindDriver BindDriver(::fidl::StringView driver_path, ::zx::vmo driver);
+
+ // Bind the requested driver to this device. `driver_path` is informational,
+ // but all calls to BindDriver/CreateDevice should use the same `driver_path`
+ // each time they use a `driver` VMO with the same contents. Returns a `status`
+ // and optionally a channel to the driver's test output. `test_output` will be
+ // not present unless the driver is configured to run its run_unit_tests hook, in
+ // which case the other end of the channel will have been passed to the driver.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::BindDriver BindDriver(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer);
+
+ // Give this device a channel to its shadow in another process.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConnectProxy ConnectProxy(::zx::channel shadow);
+
+ // Give this device a channel to its shadow in another process.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConnectProxy ConnectProxy(::fidl::BytePart _request_buffer, ::zx::channel shadow);
+
+ // Ask devhost to call the device init hook.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Init Init();
+
+ // Ask devhost to call the device init hook.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Init Init(::fidl::BytePart _response_buffer);
+
+ // Ask devhost to unbind this device. On success, the remote end of this
+ // interface channel will close instead of returning a result.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Unbind Unbind();
+
+ // Ask devhost to unbind this device. On success, the remote end of this
+ // interface channel will close instead of returning a result.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Unbind Unbind(::fidl::BytePart _response_buffer);
+
+ // Ask the devhost to complete the removal of this device, which previously had
+ // invoked |ScheduleRemove|. This is a special case that can be removed
+ // once |device_remove| invokes |unbind|.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CompleteRemoval CompleteRemoval();
+
+ // Ask the devhost to complete the removal of this device, which previously had
+ // invoked |ScheduleRemove|. This is a special case that can be removed
+ // once |device_remove| invokes |unbind|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CompleteRemoval CompleteRemoval(::fidl::BytePart _response_buffer);
+
+ // Ask devhost to suspend this device, using the target state indicated by `flags`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Suspend Suspend(uint32_t flags);
+
+ // Ask devhost to suspend this device, using the target state indicated by `flags`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Suspend Suspend(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Ask devhost to resume this device, using the target system state indicated by
+ // 'target_system_state'.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Resume Resume(uint32_t target_system_state);
+
+ // Ask devhost to resume this device, using the target system state indicated by
+ // 'target_system_state'.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Resume Resume(::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer);
+
+ // Inform devhost about the compatibility test status when compatibility tests
+ // fail or complete successfully.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CompleteCompatibilityTests CompleteCompatibilityTests(::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);
+
+ // Inform devhost about the compatibility test status when compatibility tests
+ // fail or complete successfully.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CompleteCompatibilityTests CompleteCompatibilityTests(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);
+
+ 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:
+
+ // Bind the requested driver to this device. `driver_path` is informational,
+ // but all calls to BindDriver/CreateDevice should use the same `driver_path`
+ // each time they use a `driver` VMO with the same contents. Returns a `status`
+ // and optionally a channel to the driver's test output. `test_output` will be
+ // not present unless the driver is configured to run its run_unit_tests hook, in
+ // which case the other end of the channel will have been passed to the driver.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::BindDriver BindDriver(::zx::unowned_channel _client_end, ::fidl::StringView driver_path, ::zx::vmo driver);
+
+ // Bind the requested driver to this device. `driver_path` is informational,
+ // but all calls to BindDriver/CreateDevice should use the same `driver_path`
+ // each time they use a `driver` VMO with the same contents. Returns a `status`
+ // and optionally a channel to the driver's test output. `test_output` will be
+ // not present unless the driver is configured to run its run_unit_tests hook, in
+ // which case the other end of the channel will have been passed to the driver.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::BindDriver BindDriver(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::zx::vmo driver, ::fidl::BytePart _response_buffer);
+
+ // Give this device a channel to its shadow in another process.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConnectProxy ConnectProxy(::zx::unowned_channel _client_end, ::zx::channel shadow);
+
+ // Give this device a channel to its shadow in another process.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConnectProxy ConnectProxy(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel shadow);
+
+ // Ask devhost to call the device init hook.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Init Init(::zx::unowned_channel _client_end);
+
+ // Ask devhost to call the device init hook.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Init Init(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Ask devhost to unbind this device. On success, the remote end of this
+ // interface channel will close instead of returning a result.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Unbind Unbind(::zx::unowned_channel _client_end);
+
+ // Ask devhost to unbind this device. On success, the remote end of this
+ // interface channel will close instead of returning a result.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Unbind Unbind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Ask the devhost to complete the removal of this device, which previously had
+ // invoked |ScheduleRemove|. This is a special case that can be removed
+ // once |device_remove| invokes |unbind|.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CompleteRemoval CompleteRemoval(::zx::unowned_channel _client_end);
+
+ // Ask the devhost to complete the removal of this device, which previously had
+ // invoked |ScheduleRemove|. This is a special case that can be removed
+ // once |device_remove| invokes |unbind|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CompleteRemoval CompleteRemoval(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Ask devhost to suspend this device, using the target state indicated by `flags`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Suspend Suspend(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Ask devhost to suspend this device, using the target state indicated by `flags`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Suspend Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Ask devhost to resume this device, using the target system state indicated by
+ // 'target_system_state'.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Resume Resume(::zx::unowned_channel _client_end, uint32_t target_system_state);
+
+ // Ask devhost to resume this device, using the target system state indicated by
+ // 'target_system_state'.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Resume Resume(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t target_system_state, ::fidl::BytePart _response_buffer);
+
+ // Inform devhost about the compatibility test status when compatibility tests
+ // fail or complete successfully.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CompleteCompatibilityTests CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);
+
+ // Inform devhost about the compatibility test status when compatibility tests
+ // fail or complete successfully.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CompleteCompatibilityTests CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::manager::CompatibilityTestStatus status);
+
+ };
+
+ // 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:
+
+ // Bind the requested driver to this device. `driver_path` is informational,
+ // but all calls to BindDriver/CreateDevice should use the same `driver_path`
+ // each time they use a `driver` VMO with the same contents. Returns a `status`
+ // and optionally a channel to the driver's test output. `test_output` will be
+ // not present unless the driver is configured to run its run_unit_tests hook, in
+ // which case the other end of the channel will have been passed to the driver.
+ static ::fidl::DecodeResult<BindDriverResponse> BindDriver(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDriverRequest> params, ::fidl::BytePart response_buffer);
+
+ // Give this device a channel to its shadow in another process.
+ static ::fidl::internal::StatusAndError ConnectProxy(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectProxyRequest> params);
+
+ // Ask devhost to call the device init hook.
+ static ::fidl::DecodeResult<InitResponse> Init(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Ask devhost to unbind this device. On success, the remote end of this
+ // interface channel will close instead of returning a result.
+ static ::fidl::DecodeResult<UnbindResponse> Unbind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Ask the devhost to complete the removal of this device, which previously had
+ // invoked |ScheduleRemove|. This is a special case that can be removed
+ // once |device_remove| invokes |unbind|.
+ static ::fidl::DecodeResult<CompleteRemovalResponse> CompleteRemoval(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Ask devhost to suspend this device, using the target state indicated by `flags`.
+ static ::fidl::DecodeResult<SuspendResponse> Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer);
+
+ // Ask devhost to resume this device, using the target system state indicated by
+ // 'target_system_state'.
+ static ::fidl::DecodeResult<ResumeResponse> Resume(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Inform devhost about the compatibility test status when compatibility tests
+ // fail or complete successfully.
+ static ::fidl::internal::StatusAndError CompleteCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CompleteCompatibilityTestsRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DeviceController;
+ using _Base = ::fidl::CompleterBase;
+
+ class BindDriverCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::channel test_output);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::channel test_output);
+ void Reply(::fidl::DecodedMessage<BindDriverResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BindDriverCompleter = ::fidl::Completer<BindDriverCompleterBase>;
+
+ virtual void BindDriver(::fidl::StringView driver_path, ::zx::vmo driver, BindDriverCompleter::Sync _completer) = 0;
+
+ using ConnectProxyCompleter = ::fidl::Completer<>;
+
+ virtual void ConnectProxy(::zx::channel shadow, ConnectProxyCompleter::Sync _completer) = 0;
+
+ class InitCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<InitResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using InitCompleter = ::fidl::Completer<InitCompleterBase>;
+
+ virtual void Init(InitCompleter::Sync _completer) = 0;
+
+ class UnbindCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UnbindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnbindCompleter = ::fidl::Completer<UnbindCompleterBase>;
+
+ virtual void Unbind(UnbindCompleter::Sync _completer) = 0;
+
+ class CompleteRemovalCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<CompleteRemovalResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CompleteRemovalCompleter = ::fidl::Completer<CompleteRemovalCompleterBase>;
+
+ virtual void CompleteRemoval(CompleteRemovalCompleter::Sync _completer) = 0;
+
+ class SuspendCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SuspendResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SuspendCompleter = ::fidl::Completer<SuspendCompleterBase>;
+
+ virtual void Suspend(uint32_t flags, SuspendCompleter::Sync _completer) = 0;
+
+ class ResumeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ResumeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ResumeCompleter = ::fidl::Completer<ResumeCompleterBase>;
+
+ virtual void Resume(uint32_t target_system_state, ResumeCompleter::Sync _completer) = 0;
+
+ using CompleteCompatibilityTestsCompleter = ::fidl::Completer<>;
+
+ virtual void CompleteCompatibilityTests(::llcpp::fuchsia::device::manager::CompatibilityTestStatus status, CompleteCompatibilityTestsCompleter::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 BindDriverRequest(const ::fidl::DecodedMessage<DeviceController::BindDriverRequest>& _msg);
+ static void BindDriverResponse(const ::fidl::DecodedMessage<DeviceController::BindDriverResponse>& _msg);
+ static void ConnectProxyRequest(const ::fidl::DecodedMessage<DeviceController::ConnectProxyRequest>& _msg);
+ static void InitRequest(const ::fidl::DecodedMessage<DeviceController::InitRequest>& _msg);
+ static void InitResponse(const ::fidl::DecodedMessage<DeviceController::InitResponse>& _msg);
+ static void UnbindRequest(const ::fidl::DecodedMessage<DeviceController::UnbindRequest>& _msg);
+ static void UnbindResponse(const ::fidl::DecodedMessage<DeviceController::UnbindResponse>& _msg);
+ static void CompleteRemovalRequest(const ::fidl::DecodedMessage<DeviceController::CompleteRemovalRequest>& _msg);
+ static void CompleteRemovalResponse(const ::fidl::DecodedMessage<DeviceController::CompleteRemovalResponse>& _msg);
+ static void SuspendRequest(const ::fidl::DecodedMessage<DeviceController::SuspendRequest>& _msg);
+ static void SuspendResponse(const ::fidl::DecodedMessage<DeviceController::SuspendResponse>& _msg);
+ static void ResumeRequest(const ::fidl::DecodedMessage<DeviceController::ResumeRequest>& _msg);
+ static void ResumeResponse(const ::fidl::DecodedMessage<DeviceController::ResumeResponse>& _msg);
+ static void CompleteCompatibilityTestsRequest(const ::fidl::DecodedMessage<DeviceController::CompleteCompatibilityTestsRequest>& _msg);
+ };
+};
+
+// Maximum number of components that a composite device can have
+constexpr uint32_t COMPONENTS_MAX = 16u;
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_BindInstructionTable;
+
+struct BindInstruction {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_BindInstructionTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // bitfield that encodes the operation and execution conditions
+ uint32_t op = {};
+
+ // bitfield that encodes the arguments
+ uint32_t arg = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceComponentPartTable;
+
+// A part of a description of a DeviceComponent
+struct DeviceComponentPart {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceComponentPartTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 260;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t match_program_count = {};
+
+ ::fidl::Array<::llcpp::fuchsia::device::manager::BindInstruction, 32> match_program = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_DeviceComponentTable;
+
+// A piece of a composite device
+struct DeviceComponent {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_DeviceComponentTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4164;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t parts_count = {};
+
+ ::fidl::Array<::llcpp::fuchsia::device::manager::DeviceComponentPart, 16> parts = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CompositeDeviceDescriptorTable;
+
+// Composite device parts and properties
+struct CompositeDeviceDescriptor {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CompositeDeviceDescriptorTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 331584;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint64_t> props = {};
+
+ ::fidl::VectorView<::llcpp::fuchsia::device::manager::DeviceComponent> components = {};
+
+ uint32_t coresident_device_index = {};
+
+ ::fidl::VectorView<::llcpp::fuchsia::device::manager::DeviceMetadata> metadata = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleRemoveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleRemoveResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleUnbindChildrenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorScheduleUnbindChildrenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorMakeVisibleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorMakeVisibleResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorBindDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorBindDeviceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetTopologicalPathRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetTopologicalPathResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorLoadFirmwareRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorLoadFirmwareResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorGetMetadataSizeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddMetadataRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddMetadataResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorPublishMetadataRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorPublishMetadataResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorDirectoryWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorDirectoryWatchResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsResponseTable;
+
+// Interface for the devices in devhosts to coordinate with the devcoordinator.
+class Coordinator final {
+ Coordinator() = delete;
+ public:
+
+ struct AddDeviceResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddDeviceResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AddDeviceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel coordinator;
+ ::zx::channel device_controller;
+ ::fidl::VectorView<uint64_t> props;
+ ::fidl::StringView name;
+ uint32_t protocol_id;
+ ::fidl::StringView driver_path;
+ ::fidl::StringView args;
+ ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config;
+ bool has_init;
+ ::zx::channel client_remote;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddDeviceRequestTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 112;
+ static constexpr uint32_t MaxOutOfLine = 4128;
+ static constexpr uint32_t AltPrimarySize = 112;
+ static constexpr uint32_t AltMaxOutOfLine = 4128;
+ 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 = AddDeviceResponse;
+ };
+
+ struct AddDeviceInvisibleResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AddDeviceInvisibleRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel coordinator;
+ ::zx::channel device_controller;
+ ::fidl::VectorView<uint64_t> props;
+ ::fidl::StringView name;
+ uint32_t protocol_id;
+ ::fidl::StringView driver_path;
+ ::fidl::StringView args;
+ bool has_init;
+ ::zx::channel client_remote;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddDeviceInvisibleRequestTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 104;
+ static constexpr uint32_t MaxOutOfLine = 4128;
+ static constexpr uint32_t AltPrimarySize = 104;
+ static constexpr uint32_t AltMaxOutOfLine = 4128;
+ 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 = AddDeviceInvisibleResponse;
+ };
+
+ struct ScheduleRemoveRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool unbind_self;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorScheduleRemoveRequestTable;
+ 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 ScheduleUnbindChildrenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct MakeVisibleResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorMakeVisibleResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using MakeVisibleRequest = ::fidl::AnyZeroArgMessage;
+
+ struct BindDeviceResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorBindDeviceResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct BindDeviceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView driver_path;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorBindDeviceRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = BindDeviceResponse;
+ };
+
+ struct GetTopologicalPathResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetTopologicalPathResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 1040;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetTopologicalPathRequest = ::fidl::AnyZeroArgMessage;
+
+ struct LoadFirmwareResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorLoadFirmwareResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct LoadFirmwareRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView fw_path;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorLoadFirmwareRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = LoadFirmwareResponse;
+ };
+
+ struct GetMetadataResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetMetadataResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8208;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetMetadataRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t key;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetMetadataRequestTable;
+ 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 = GetMetadataResponse;
+ };
+
+ struct GetMetadataSizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetMetadataSizeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetMetadataSizeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t key;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorGetMetadataSizeRequestTable;
+ 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 = GetMetadataSizeResponse;
+ };
+
+ struct AddMetadataResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddMetadataResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AddMetadataRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t key;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddMetadataRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = AddMetadataResponse;
+ };
+
+ struct PublishMetadataResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorPublishMetadataResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct PublishMetadataRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView device_path;
+ uint32_t key;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorPublishMetadataRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 9216;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 9216;
+ 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 = PublishMetadataResponse;
+ };
+
+ struct AddCompositeDeviceResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AddCompositeDeviceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView name;
+ ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorAddCompositeDeviceRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 88;
+ static constexpr uint32_t MaxOutOfLine = 331616;
+ static constexpr uint32_t AltPrimarySize = 88;
+ static constexpr uint32_t AltMaxOutOfLine = 331616;
+ 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 = AddCompositeDeviceResponse;
+ };
+
+ struct DirectoryWatchResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorDirectoryWatchResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct DirectoryWatchRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t mask;
+ uint32_t options;
+ ::zx::channel watcher;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorDirectoryWatchRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = DirectoryWatchResponse;
+ };
+
+ struct RunCompatibilityTestsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RunCompatibilityTestsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int64_t hook_wait_time;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_manager_CoordinatorRunCompatibilityTestsRequestTable;
+ 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 = RunCompatibilityTestsResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class AddDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AddDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote);
+ ~AddDevice_Impl() = default;
+ AddDevice_Impl(AddDevice_Impl&& other) = default;
+ AddDevice_Impl& operator=(AddDevice_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 AddDeviceInvisible_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AddDeviceInvisible_Impl(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote);
+ ~AddDeviceInvisible_Impl() = default;
+ AddDeviceInvisible_Impl(AddDeviceInvisible_Impl&& other) = default;
+ AddDeviceInvisible_Impl& operator=(AddDeviceInvisible_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ScheduleRemove_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ScheduleRemove_Impl(::zx::unowned_channel _client_end, bool unbind_self);
+ ~ScheduleRemove_Impl() = default;
+ ScheduleRemove_Impl(ScheduleRemove_Impl&& other) = default;
+ ScheduleRemove_Impl& operator=(ScheduleRemove_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class ScheduleUnbindChildren_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ScheduleUnbindChildren_Impl(::zx::unowned_channel _client_end);
+ ~ScheduleUnbindChildren_Impl() = default;
+ ScheduleUnbindChildren_Impl(ScheduleUnbindChildren_Impl&& other) = default;
+ ScheduleUnbindChildren_Impl& operator=(ScheduleUnbindChildren_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class MakeVisible_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ MakeVisible_Impl(::zx::unowned_channel _client_end);
+ ~MakeVisible_Impl() = default;
+ MakeVisible_Impl(MakeVisible_Impl&& other) = default;
+ MakeVisible_Impl& operator=(MakeVisible_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 BindDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ BindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver_path);
+ ~BindDevice_Impl() = default;
+ BindDevice_Impl(BindDevice_Impl&& other) = default;
+ BindDevice_Impl& operator=(BindDevice_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 GetTopologicalPath_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetTopologicalPath_Impl(::zx::unowned_channel _client_end);
+ ~GetTopologicalPath_Impl() = default;
+ GetTopologicalPath_Impl(GetTopologicalPath_Impl&& other) = default;
+ GetTopologicalPath_Impl& operator=(GetTopologicalPath_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 LoadFirmware_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LoadFirmware_Impl(::zx::unowned_channel _client_end, ::fidl::StringView fw_path);
+ ~LoadFirmware_Impl() = default;
+ LoadFirmware_Impl(LoadFirmware_Impl&& other) = default;
+ LoadFirmware_Impl& operator=(LoadFirmware_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 GetMetadata_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetMetadata_Impl(::zx::unowned_channel _client_end, uint32_t key);
+ ~GetMetadata_Impl() = default;
+ GetMetadata_Impl(GetMetadata_Impl&& other) = default;
+ GetMetadata_Impl& operator=(GetMetadata_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 GetMetadataSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetMetadataSize_Impl(::zx::unowned_channel _client_end, uint32_t key);
+ ~GetMetadataSize_Impl() = default;
+ GetMetadataSize_Impl(GetMetadataSize_Impl&& other) = default;
+ GetMetadataSize_Impl& operator=(GetMetadataSize_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 AddMetadata_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AddMetadata_Impl(::zx::unowned_channel _client_end, uint32_t key, ::fidl::VectorView<uint8_t> data);
+ ~AddMetadata_Impl() = default;
+ AddMetadata_Impl(AddMetadata_Impl&& other) = default;
+ AddMetadata_Impl& operator=(AddMetadata_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 PublishMetadata_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ PublishMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data);
+ ~PublishMetadata_Impl() = default;
+ PublishMetadata_Impl(PublishMetadata_Impl&& other) = default;
+ PublishMetadata_Impl& operator=(PublishMetadata_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 AddCompositeDevice_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AddCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc);
+ ~AddCompositeDevice_Impl() = default;
+ AddCompositeDevice_Impl(AddCompositeDevice_Impl&& other) = default;
+ AddCompositeDevice_Impl& operator=(AddCompositeDevice_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 DirectoryWatch_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ DirectoryWatch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
+ ~DirectoryWatch_Impl() = default;
+ DirectoryWatch_Impl(DirectoryWatch_Impl&& other) = default;
+ DirectoryWatch_Impl& operator=(DirectoryWatch_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 RunCompatibilityTests_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, int64_t hook_wait_time);
+ ~RunCompatibilityTests_Impl() = default;
+ RunCompatibilityTests_Impl(RunCompatibilityTests_Impl&& other) = default;
+ RunCompatibilityTests_Impl& operator=(RunCompatibilityTests_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 AddDevice = AddDevice_Impl<AddDeviceResponse>;
+ using AddDeviceInvisible = AddDeviceInvisible_Impl<AddDeviceInvisibleResponse>;
+ using ScheduleRemove = ScheduleRemove_Impl;
+ using ScheduleUnbindChildren = ScheduleUnbindChildren_Impl;
+ using MakeVisible = MakeVisible_Impl<MakeVisibleResponse>;
+ using BindDevice = BindDevice_Impl<BindDeviceResponse>;
+ using GetTopologicalPath = GetTopologicalPath_Impl<GetTopologicalPathResponse>;
+ using LoadFirmware = LoadFirmware_Impl<LoadFirmwareResponse>;
+ using GetMetadata = GetMetadata_Impl<GetMetadataResponse>;
+ using GetMetadataSize = GetMetadataSize_Impl<GetMetadataSizeResponse>;
+ using AddMetadata = AddMetadata_Impl<AddMetadataResponse>;
+ using PublishMetadata = PublishMetadata_Impl<PublishMetadataResponse>;
+ using AddCompositeDevice = AddCompositeDevice_Impl<AddCompositeDeviceResponse>;
+ using DirectoryWatch = DirectoryWatch_Impl<DirectoryWatchResponse>;
+ using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
+ };
+
+ // 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 AddDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AddDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);
+ ~AddDevice_Impl() = default;
+ AddDevice_Impl(AddDevice_Impl&& other) = default;
+ AddDevice_Impl& operator=(AddDevice_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 AddDeviceInvisible_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AddDeviceInvisible_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);
+ ~AddDeviceInvisible_Impl() = default;
+ AddDeviceInvisible_Impl(AddDeviceInvisible_Impl&& other) = default;
+ AddDeviceInvisible_Impl& operator=(AddDeviceInvisible_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ScheduleRemove_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ScheduleRemove_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool unbind_self);
+ ~ScheduleRemove_Impl() = default;
+ ScheduleRemove_Impl(ScheduleRemove_Impl&& other) = default;
+ ScheduleRemove_Impl& operator=(ScheduleRemove_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class ScheduleUnbindChildren_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ScheduleUnbindChildren_Impl(::zx::unowned_channel _client_end);
+ ~ScheduleUnbindChildren_Impl() = default;
+ ScheduleUnbindChildren_Impl(ScheduleUnbindChildren_Impl&& other) = default;
+ ScheduleUnbindChildren_Impl& operator=(ScheduleUnbindChildren_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class MakeVisible_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ MakeVisible_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~MakeVisible_Impl() = default;
+ MakeVisible_Impl(MakeVisible_Impl&& other) = default;
+ MakeVisible_Impl& operator=(MakeVisible_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 BindDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ BindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer);
+ ~BindDevice_Impl() = default;
+ BindDevice_Impl(BindDevice_Impl&& other) = default;
+ BindDevice_Impl& operator=(BindDevice_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 GetTopologicalPath_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetTopologicalPath_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetTopologicalPath_Impl() = default;
+ GetTopologicalPath_Impl(GetTopologicalPath_Impl&& other) = default;
+ GetTopologicalPath_Impl& operator=(GetTopologicalPath_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 LoadFirmware_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LoadFirmware_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer);
+ ~LoadFirmware_Impl() = default;
+ LoadFirmware_Impl(LoadFirmware_Impl&& other) = default;
+ LoadFirmware_Impl& operator=(LoadFirmware_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 GetMetadata_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);
+ ~GetMetadata_Impl() = default;
+ GetMetadata_Impl(GetMetadata_Impl&& other) = default;
+ GetMetadata_Impl& operator=(GetMetadata_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 GetMetadataSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetMetadataSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);
+ ~GetMetadataSize_Impl() = default;
+ GetMetadataSize_Impl(GetMetadataSize_Impl&& other) = default;
+ GetMetadataSize_Impl& operator=(GetMetadataSize_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 AddMetadata_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AddMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+ ~AddMetadata_Impl() = default;
+ AddMetadata_Impl(AddMetadata_Impl&& other) = default;
+ AddMetadata_Impl& operator=(AddMetadata_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 PublishMetadata_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ PublishMetadata_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+ ~PublishMetadata_Impl() = default;
+ PublishMetadata_Impl(PublishMetadata_Impl&& other) = default;
+ PublishMetadata_Impl& operator=(PublishMetadata_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 AddCompositeDevice_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AddCompositeDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer);
+ ~AddCompositeDevice_Impl() = default;
+ AddCompositeDevice_Impl(AddCompositeDevice_Impl&& other) = default;
+ AddCompositeDevice_Impl& operator=(AddCompositeDevice_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 DirectoryWatch_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ DirectoryWatch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+ ~DirectoryWatch_Impl() = default;
+ DirectoryWatch_Impl(DirectoryWatch_Impl&& other) = default;
+ DirectoryWatch_Impl& operator=(DirectoryWatch_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 RunCompatibilityTests_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer);
+ ~RunCompatibilityTests_Impl() = default;
+ RunCompatibilityTests_Impl(RunCompatibilityTests_Impl&& other) = default;
+ RunCompatibilityTests_Impl& operator=(RunCompatibilityTests_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 AddDevice = AddDevice_Impl<AddDeviceResponse>;
+ using AddDeviceInvisible = AddDeviceInvisible_Impl<AddDeviceInvisibleResponse>;
+ using ScheduleRemove = ScheduleRemove_Impl;
+ using ScheduleUnbindChildren = ScheduleUnbindChildren_Impl;
+ using MakeVisible = MakeVisible_Impl<MakeVisibleResponse>;
+ using BindDevice = BindDevice_Impl<BindDeviceResponse>;
+ using GetTopologicalPath = GetTopologicalPath_Impl<GetTopologicalPathResponse>;
+ using LoadFirmware = LoadFirmware_Impl<LoadFirmwareResponse>;
+ using GetMetadata = GetMetadata_Impl<GetMetadataResponse>;
+ using GetMetadataSize = GetMetadataSize_Impl<GetMetadataSizeResponse>;
+ using AddMetadata = AddMetadata_Impl<AddMetadataResponse>;
+ using PublishMetadata = PublishMetadata_Impl<PublishMetadataResponse>;
+ using AddCompositeDevice = AddCompositeDevice_Impl<AddCompositeDeviceResponse>;
+ using DirectoryWatch = DirectoryWatch_Impl<DirectoryWatchResponse>;
+ using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
+ };
+
+ 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_; }
+
+ // Record the addition of a new device that can be communicated with via `rpc`.
+ // For binding purposes, it is has properties `props`. `name` and `driver_path`
+ // are informational and used for debugging. The device will have `protocol_id`
+ // as its primary protocol id. `args` should only be used for shadowed devices,
+ // and will be forwarded to the shadow device. `client_remote`, if present,
+ // will be passed to the device as an open connection for the client.
+ // On success, the returned `local_device_id` is the identifier assigned by devmgr.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::AddDevice AddDevice(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote);
+
+ // Record the addition of a new device that can be communicated with via `rpc`.
+ // For binding purposes, it is has properties `props`. `name` and `driver_path`
+ // are informational and used for debugging. The device will have `protocol_id`
+ // as its primary protocol id. `args` should only be used for shadowed devices,
+ // and will be forwarded to the shadow device. `client_remote`, if present,
+ // will be passed to the device as an open connection for the client.
+ // On success, the returned `local_device_id` is the identifier assigned by devmgr.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddDevice AddDevice(::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);
+
+ // Behaves as AddDevice, but marks the device as initially invisible. This means
+ // that it will not be visible to other devices or the devfs until it is later marked
+ // visible (via MakeVisible).
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::AddDeviceInvisible AddDeviceInvisible(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote);
+
+ // Behaves as AddDevice, but marks the device as initially invisible. This means
+ // that it will not be visible to other devices or the devfs until it is later marked
+ // visible (via MakeVisible).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddDeviceInvisible AddDeviceInvisible(::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);
+
+ // Requests the devcoordinator schedule the removal of this device,
+ // and the unbinding of its children.
+ // If |unbind_self| is true, the unbind hook for this device will also be called.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ScheduleRemove ScheduleRemove(bool unbind_self);
+
+ // Requests the devcoordinator schedule the removal of this device,
+ // and the unbinding of its children.
+ // If |unbind_self| is true, the unbind hook for this device will also be called.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ScheduleRemove ScheduleRemove(::fidl::BytePart _request_buffer, bool unbind_self);
+
+ // Requests the devcoordinator schedule the unbinding of this device's children.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ScheduleUnbindChildren ScheduleUnbindChildren();
+
+
+ // Mark this device as visible.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::MakeVisible MakeVisible();
+
+ // Mark this device as visible.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::MakeVisible MakeVisible(::fidl::BytePart _response_buffer);
+
+ // Attempt to bind a driver against this device. If `driver_path` is null,
+ // this will initiate the driver matching algorithm.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::BindDevice BindDevice(::fidl::StringView driver_path);
+
+ // Attempt to bind a driver against this device. If `driver_path` is null,
+ // this will initiate the driver matching algorithm.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::BindDevice BindDevice(::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer);
+
+ // Returns the topological path of this device.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetTopologicalPath GetTopologicalPath();
+
+ // Returns the topological path of this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetTopologicalPath GetTopologicalPath(::fidl::BytePart _response_buffer);
+
+ // Requests that the firmware at the given path be loaded and returned.
+ // Allocates 56 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::LoadFirmware LoadFirmware(::fidl::StringView fw_path);
+
+ // Requests that the firmware at the given path be loaded and returned.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LoadFirmware LoadFirmware(::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer);
+
+ // Retrieve the metadata blob associated with this device and the given key.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetMetadata GetMetadata(uint32_t key);
+
+ // Retrieve the metadata blob associated with this device and the given key.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetMetadata GetMetadata(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);
+
+ // Retrieve the metadata size associated with this device and the given key.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetMetadataSize GetMetadataSize(uint32_t key);
+
+ // Retrieve the metadata size associated with this device and the given key.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetMetadataSize GetMetadataSize(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);
+
+ // Add metadata blob associated with this device and the given key.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::AddMetadata AddMetadata(uint32_t key, ::fidl::VectorView<uint8_t> data);
+
+ // Add metadata blob associated with this device and the given key.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddMetadata AddMetadata(::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Behaves like AddMetadata, but instead of associating it with the
+ // requesting device, associates it with the device at `device_path`. If
+ // the device at `device_path` is not a child of the requesting device AND
+ // the requesting device is not running in the sys devhost, then this will
+ // fail.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::PublishMetadata PublishMetadata(::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data);
+
+ // Behaves like AddMetadata, but instead of associating it with the
+ // requesting device, associates it with the device at `device_path`. If
+ // the device at `device_path` is not a child of the requesting device AND
+ // the requesting device is not running in the sys devhost, then this will
+ // fail.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::PublishMetadata PublishMetadata(::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Adds the given composite device. This causes the devcoordinator to try to match the
+ // components against the existing device tree, and to monitor all new device additions
+ // in order to find the components as they are created.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::AddCompositeDevice AddCompositeDevice(::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc);
+
+ // Adds the given composite device. This causes the devcoordinator to try to match the
+ // components against the existing device tree, and to monitor all new device additions
+ // in order to find the components as they are created.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddCompositeDevice AddCompositeDevice(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ // See fuchsia.io.Directory for more information.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DirectoryWatch DirectoryWatch(uint32_t mask, uint32_t options, ::zx::channel watcher);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ // See fuchsia.io.Directory for more information.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DirectoryWatch DirectoryWatch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+
+ // Run Compatibility tests for the driver that binds to this device.
+ // The hook_wait_time is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the compatibility tests started, and does not convey
+ // anything about the status of the test.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RunCompatibilityTests RunCompatibilityTests(int64_t hook_wait_time);
+
+ // Run Compatibility tests for the driver that binds to this device.
+ // The hook_wait_time is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the compatibility tests started, and does not convey
+ // anything about the status of the test.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RunCompatibilityTests RunCompatibilityTests(::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::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:
+
+ // Record the addition of a new device that can be communicated with via `rpc`.
+ // For binding purposes, it is has properties `props`. `name` and `driver_path`
+ // are informational and used for debugging. The device will have `protocol_id`
+ // as its primary protocol id. `args` should only be used for shadowed devices,
+ // and will be forwarded to the shadow device. `client_remote`, if present,
+ // will be passed to the device as an open connection for the client.
+ // On success, the returned `local_device_id` is the identifier assigned by devmgr.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::AddDevice AddDevice(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote);
+
+ // Record the addition of a new device that can be communicated with via `rpc`.
+ // For binding purposes, it is has properties `props`. `name` and `driver_path`
+ // are informational and used for debugging. The device will have `protocol_id`
+ // as its primary protocol id. `args` should only be used for shadowed devices,
+ // and will be forwarded to the shadow device. `client_remote`, if present,
+ // will be passed to the device as an open connection for the client.
+ // On success, the returned `local_device_id` is the identifier assigned by devmgr.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddDevice AddDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);
+
+ // Behaves as AddDevice, but marks the device as initially invisible. This means
+ // that it will not be visible to other devices or the devfs until it is later marked
+ // visible (via MakeVisible).
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::AddDeviceInvisible AddDeviceInvisible(::zx::unowned_channel _client_end, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote);
+
+ // Behaves as AddDevice, but marks the device as initially invisible. This means
+ // that it will not be visible to other devices or the devfs until it is later marked
+ // visible (via MakeVisible).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddDeviceInvisible AddDeviceInvisible(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, ::fidl::BytePart _response_buffer);
+
+ // Requests the devcoordinator schedule the removal of this device,
+ // and the unbinding of its children.
+ // If |unbind_self| is true, the unbind hook for this device will also be called.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ScheduleRemove ScheduleRemove(::zx::unowned_channel _client_end, bool unbind_self);
+
+ // Requests the devcoordinator schedule the removal of this device,
+ // and the unbinding of its children.
+ // If |unbind_self| is true, the unbind hook for this device will also be called.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ScheduleRemove ScheduleRemove(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool unbind_self);
+
+ // Requests the devcoordinator schedule the unbinding of this device's children.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ScheduleUnbindChildren ScheduleUnbindChildren(::zx::unowned_channel _client_end);
+
+
+ // Mark this device as visible.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::MakeVisible MakeVisible(::zx::unowned_channel _client_end);
+
+ // Mark this device as visible.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::MakeVisible MakeVisible(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Attempt to bind a driver against this device. If `driver_path` is null,
+ // this will initiate the driver matching algorithm.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::BindDevice BindDevice(::zx::unowned_channel _client_end, ::fidl::StringView driver_path);
+
+ // Attempt to bind a driver against this device. If `driver_path` is null,
+ // this will initiate the driver matching algorithm.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::BindDevice BindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver_path, ::fidl::BytePart _response_buffer);
+
+ // Returns the topological path of this device.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetTopologicalPath GetTopologicalPath(::zx::unowned_channel _client_end);
+
+ // Returns the topological path of this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetTopologicalPath GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Requests that the firmware at the given path be loaded and returned.
+ // Allocates 56 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::LoadFirmware LoadFirmware(::zx::unowned_channel _client_end, ::fidl::StringView fw_path);
+
+ // Requests that the firmware at the given path be loaded and returned.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LoadFirmware LoadFirmware(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView fw_path, ::fidl::BytePart _response_buffer);
+
+ // Retrieve the metadata blob associated with this device and the given key.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetMetadata GetMetadata(::zx::unowned_channel _client_end, uint32_t key);
+
+ // Retrieve the metadata blob associated with this device and the given key.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetMetadata GetMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);
+
+ // Retrieve the metadata size associated with this device and the given key.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetMetadataSize GetMetadataSize(::zx::unowned_channel _client_end, uint32_t key);
+
+ // Retrieve the metadata size associated with this device and the given key.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetMetadataSize GetMetadataSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::BytePart _response_buffer);
+
+ // Add metadata blob associated with this device and the given key.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::AddMetadata AddMetadata(::zx::unowned_channel _client_end, uint32_t key, ::fidl::VectorView<uint8_t> data);
+
+ // Add metadata blob associated with this device and the given key.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddMetadata AddMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Behaves like AddMetadata, but instead of associating it with the
+ // requesting device, associates it with the device at `device_path`. If
+ // the device at `device_path` is not a child of the requesting device AND
+ // the requesting device is not running in the sys devhost, then this will
+ // fail.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::PublishMetadata PublishMetadata(::zx::unowned_channel _client_end, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data);
+
+ // Behaves like AddMetadata, but instead of associating it with the
+ // requesting device, associates it with the device at `device_path`. If
+ // the device at `device_path` is not a child of the requesting device AND
+ // the requesting device is not running in the sys devhost, then this will
+ // fail.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::PublishMetadata PublishMetadata(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Adds the given composite device. This causes the devcoordinator to try to match the
+ // components against the existing device tree, and to monitor all new device additions
+ // in order to find the components as they are created.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::AddCompositeDevice AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc);
+
+ // Adds the given composite device. This causes the devcoordinator to try to match the
+ // components against the existing device tree, and to monitor all new device additions
+ // in order to find the components as they are created.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddCompositeDevice AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ // See fuchsia.io.Directory for more information.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DirectoryWatch DirectoryWatch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ // See fuchsia.io.Directory for more information.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DirectoryWatch DirectoryWatch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+
+ // Run Compatibility tests for the driver that binds to this device.
+ // The hook_wait_time is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the compatibility tests started, and does not convey
+ // anything about the status of the test.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RunCompatibilityTests RunCompatibilityTests(::zx::unowned_channel _client_end, int64_t hook_wait_time);
+
+ // Run Compatibility tests for the driver that binds to this device.
+ // The hook_wait_time is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the compatibility tests started, and does not convey
+ // anything about the status of the test.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RunCompatibilityTests RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::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:
+
+ // Record the addition of a new device that can be communicated with via `rpc`.
+ // For binding purposes, it is has properties `props`. `name` and `driver_path`
+ // are informational and used for debugging. The device will have `protocol_id`
+ // as its primary protocol id. `args` should only be used for shadowed devices,
+ // and will be forwarded to the shadow device. `client_remote`, if present,
+ // will be passed to the device as an open connection for the client.
+ // On success, the returned `local_device_id` is the identifier assigned by devmgr.
+ static ::fidl::DecodeResult<AddDeviceResponse> AddDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceRequest> params, ::fidl::BytePart response_buffer);
+
+ // Behaves as AddDevice, but marks the device as initially invisible. This means
+ // that it will not be visible to other devices or the devfs until it is later marked
+ // visible (via MakeVisible).
+ static ::fidl::DecodeResult<AddDeviceInvisibleResponse> AddDeviceInvisible(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddDeviceInvisibleRequest> params, ::fidl::BytePart response_buffer);
+
+ // Requests the devcoordinator schedule the removal of this device,
+ // and the unbinding of its children.
+ // If |unbind_self| is true, the unbind hook for this device will also be called.
+ static ::fidl::internal::StatusAndError ScheduleRemove(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ScheduleRemoveRequest> params);
+
+ // Requests the devcoordinator schedule the unbinding of this device's children.
+ static ::fidl::internal::StatusAndError ScheduleUnbindChildren(::zx::unowned_channel _client_end);
+
+ // Mark this device as visible.
+ static ::fidl::DecodeResult<MakeVisibleResponse> MakeVisible(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Attempt to bind a driver against this device. If `driver_path` is null,
+ // this will initiate the driver matching algorithm.
+ static ::fidl::DecodeResult<BindDeviceResponse> BindDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindDeviceRequest> params, ::fidl::BytePart response_buffer);
+
+ // Returns the topological path of this device.
+ static ::fidl::DecodeResult<GetTopologicalPathResponse> GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Requests that the firmware at the given path be loaded and returned.
+ static ::fidl::DecodeResult<LoadFirmwareResponse> LoadFirmware(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LoadFirmwareRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieve the metadata blob associated with this device and the given key.
+ static ::fidl::DecodeResult<GetMetadataResponse> GetMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMetadataRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieve the metadata size associated with this device and the given key.
+ static ::fidl::DecodeResult<GetMetadataSizeResponse> GetMetadataSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMetadataSizeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Add metadata blob associated with this device and the given key.
+ static ::fidl::DecodeResult<AddMetadataResponse> AddMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddMetadataRequest> params, ::fidl::BytePart response_buffer);
+
+ // Behaves like AddMetadata, but instead of associating it with the
+ // requesting device, associates it with the device at `device_path`. If
+ // the device at `device_path` is not a child of the requesting device AND
+ // the requesting device is not running in the sys devhost, then this will
+ // fail.
+ static ::fidl::DecodeResult<PublishMetadataResponse> PublishMetadata(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PublishMetadataRequest> params, ::fidl::BytePart response_buffer);
+
+ // Adds the given composite device. This causes the devcoordinator to try to match the
+ // components against the existing device tree, and to monitor all new device additions
+ // in order to find the components as they are created.
+ static ::fidl::DecodeResult<AddCompositeDeviceResponse> AddCompositeDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddCompositeDeviceRequest> params, ::fidl::BytePart response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ // See fuchsia.io.Directory for more information.
+ static ::fidl::DecodeResult<DirectoryWatchResponse> DirectoryWatch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DirectoryWatchRequest> params, ::fidl::BytePart response_buffer);
+
+ // Run Compatibility tests for the driver that binds to this device.
+ // The hook_wait_time is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the compatibility tests started, and does not convey
+ // anything about the status of the test.
+ static ::fidl::DecodeResult<RunCompatibilityTestsResponse> RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RunCompatibilityTestsRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Coordinator;
+ using _Base = ::fidl::CompleterBase;
+
+ class AddDeviceCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result result);
+ void ReplySuccess(uint64_t local_device_id);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint64_t local_device_id);
+ void Reply(::fidl::DecodedMessage<AddDeviceResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AddDeviceCompleter = ::fidl::Completer<AddDeviceCompleterBase>;
+
+ virtual void AddDevice(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, ::llcpp::fuchsia::device::manager::AddDeviceConfig device_add_config, bool has_init, ::zx::channel client_remote, AddDeviceCompleter::Sync _completer) = 0;
+
+ class AddDeviceInvisibleCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result result);
+ void ReplySuccess(uint64_t local_device_id);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint64_t local_device_id);
+ void Reply(::fidl::DecodedMessage<AddDeviceInvisibleResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AddDeviceInvisibleCompleter = ::fidl::Completer<AddDeviceInvisibleCompleterBase>;
+
+ virtual void AddDeviceInvisible(::zx::channel coordinator, ::zx::channel device_controller, ::fidl::VectorView<uint64_t> props, ::fidl::StringView name, uint32_t protocol_id, ::fidl::StringView driver_path, ::fidl::StringView args, bool has_init, ::zx::channel client_remote, AddDeviceInvisibleCompleter::Sync _completer) = 0;
+
+ using ScheduleRemoveCompleter = ::fidl::Completer<>;
+
+ virtual void ScheduleRemove(bool unbind_self, ScheduleRemoveCompleter::Sync _completer) = 0;
+
+ using ScheduleUnbindChildrenCompleter = ::fidl::Completer<>;
+
+ virtual void ScheduleUnbindChildren(ScheduleUnbindChildrenCompleter::Sync _completer) = 0;
+
+ class MakeVisibleCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<MakeVisibleResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using MakeVisibleCompleter = ::fidl::Completer<MakeVisibleCompleterBase>;
+
+ virtual void MakeVisible(MakeVisibleCompleter::Sync _completer) = 0;
+
+ class BindDeviceCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<BindDeviceResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BindDeviceCompleter = ::fidl::Completer<BindDeviceCompleterBase>;
+
+ virtual void BindDevice(::fidl::StringView driver_path, BindDeviceCompleter::Sync _completer) = 0;
+
+ class GetTopologicalPathCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result result);
+ void ReplySuccess(::fidl::StringView path);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView path);
+ void Reply(::fidl::DecodedMessage<GetTopologicalPathResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTopologicalPathCompleter = ::fidl::Completer<GetTopologicalPathCompleterBase>;
+
+ virtual void GetTopologicalPath(GetTopologicalPathCompleter::Sync _completer) = 0;
+
+ class LoadFirmwareCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result result);
+ void ReplySuccess(::zx::vmo vmo, uint64_t size);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::vmo vmo, uint64_t size);
+ void Reply(::fidl::DecodedMessage<LoadFirmwareResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LoadFirmwareCompleter = ::fidl::Completer<LoadFirmwareCompleterBase>;
+
+ virtual void LoadFirmware(::fidl::StringView fw_path, LoadFirmwareCompleter::Sync _completer) = 0;
+
+ class GetMetadataCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> data);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<GetMetadataResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetMetadataCompleter = ::fidl::Completer<GetMetadataCompleterBase>;
+
+ virtual void GetMetadata(uint32_t key, GetMetadataCompleter::Sync _completer) = 0;
+
+ class GetMetadataSizeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result result);
+ void ReplySuccess(uint64_t size);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint64_t size);
+ void Reply(::fidl::DecodedMessage<GetMetadataSizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetMetadataSizeCompleter = ::fidl::Completer<GetMetadataSizeCompleterBase>;
+
+ virtual void GetMetadataSize(uint32_t key, GetMetadataSizeCompleter::Sync _completer) = 0;
+
+ class AddMetadataCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<AddMetadataResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AddMetadataCompleter = ::fidl::Completer<AddMetadataCompleterBase>;
+
+ virtual void AddMetadata(uint32_t key, ::fidl::VectorView<uint8_t> data, AddMetadataCompleter::Sync _completer) = 0;
+
+ class PublishMetadataCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<PublishMetadataResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using PublishMetadataCompleter = ::fidl::Completer<PublishMetadataCompleterBase>;
+
+ virtual void PublishMetadata(::fidl::StringView device_path, uint32_t key, ::fidl::VectorView<uint8_t> data, PublishMetadataCompleter::Sync _completer) = 0;
+
+ class AddCompositeDeviceCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<AddCompositeDeviceResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AddCompositeDeviceCompleter = ::fidl::Completer<AddCompositeDeviceCompleterBase>;
+
+ virtual void AddCompositeDevice(::fidl::StringView name, ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor comp_desc, AddCompositeDeviceCompleter::Sync _completer) = 0;
+
+ class DirectoryWatchCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<DirectoryWatchResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DirectoryWatchCompleter = ::fidl::Completer<DirectoryWatchCompleterBase>;
+
+ virtual void DirectoryWatch(uint32_t mask, uint32_t options, ::zx::channel watcher, DirectoryWatchCompleter::Sync _completer) = 0;
+
+ class RunCompatibilityTestsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<RunCompatibilityTestsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RunCompatibilityTestsCompleter = ::fidl::Completer<RunCompatibilityTestsCompleterBase>;
+
+ virtual void RunCompatibilityTests(int64_t hook_wait_time, RunCompatibilityTestsCompleter::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 AddDeviceRequest(const ::fidl::DecodedMessage<Coordinator::AddDeviceRequest>& _msg);
+ static void AddDeviceResponse(const ::fidl::DecodedMessage<Coordinator::AddDeviceResponse>& _msg);
+ static void AddDeviceInvisibleRequest(const ::fidl::DecodedMessage<Coordinator::AddDeviceInvisibleRequest>& _msg);
+ static void AddDeviceInvisibleResponse(const ::fidl::DecodedMessage<Coordinator::AddDeviceInvisibleResponse>& _msg);
+ static void ScheduleRemoveRequest(const ::fidl::DecodedMessage<Coordinator::ScheduleRemoveRequest>& _msg);
+ static void ScheduleUnbindChildrenRequest(const ::fidl::DecodedMessage<Coordinator::ScheduleUnbindChildrenRequest>& _msg);
+ static void MakeVisibleRequest(const ::fidl::DecodedMessage<Coordinator::MakeVisibleRequest>& _msg);
+ static void MakeVisibleResponse(const ::fidl::DecodedMessage<Coordinator::MakeVisibleResponse>& _msg);
+ static void BindDeviceRequest(const ::fidl::DecodedMessage<Coordinator::BindDeviceRequest>& _msg);
+ static void BindDeviceResponse(const ::fidl::DecodedMessage<Coordinator::BindDeviceResponse>& _msg);
+ static void GetTopologicalPathRequest(const ::fidl::DecodedMessage<Coordinator::GetTopologicalPathRequest>& _msg);
+ static void GetTopologicalPathResponse(const ::fidl::DecodedMessage<Coordinator::GetTopologicalPathResponse>& _msg);
+ static void LoadFirmwareRequest(const ::fidl::DecodedMessage<Coordinator::LoadFirmwareRequest>& _msg);
+ static void LoadFirmwareResponse(const ::fidl::DecodedMessage<Coordinator::LoadFirmwareResponse>& _msg);
+ static void GetMetadataRequest(const ::fidl::DecodedMessage<Coordinator::GetMetadataRequest>& _msg);
+ static void GetMetadataResponse(const ::fidl::DecodedMessage<Coordinator::GetMetadataResponse>& _msg);
+ static void GetMetadataSizeRequest(const ::fidl::DecodedMessage<Coordinator::GetMetadataSizeRequest>& _msg);
+ static void GetMetadataSizeResponse(const ::fidl::DecodedMessage<Coordinator::GetMetadataSizeResponse>& _msg);
+ static void AddMetadataRequest(const ::fidl::DecodedMessage<Coordinator::AddMetadataRequest>& _msg);
+ static void AddMetadataResponse(const ::fidl::DecodedMessage<Coordinator::AddMetadataResponse>& _msg);
+ static void PublishMetadataRequest(const ::fidl::DecodedMessage<Coordinator::PublishMetadataRequest>& _msg);
+ static void PublishMetadataResponse(const ::fidl::DecodedMessage<Coordinator::PublishMetadataResponse>& _msg);
+ static void AddCompositeDeviceRequest(const ::fidl::DecodedMessage<Coordinator::AddCompositeDeviceRequest>& _msg);
+ static void AddCompositeDeviceResponse(const ::fidl::DecodedMessage<Coordinator::AddCompositeDeviceResponse>& _msg);
+ static void DirectoryWatchRequest(const ::fidl::DecodedMessage<Coordinator::DirectoryWatchRequest>& _msg);
+ static void DirectoryWatchResponse(const ::fidl::DecodedMessage<Coordinator::DirectoryWatchResponse>& _msg);
+ static void RunCompatibilityTestsRequest(const ::fidl::DecodedMessage<Coordinator::RunCompatibilityTestsRequest>& _msg);
+ static void RunCompatibilityTestsResponse(const ::fidl::DecodedMessage<Coordinator::RunCompatibilityTestsResponse>& _msg);
+ };
+};
+
+} // namespace manager
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest)
+ == ::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeRequest, output) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse)
+ == ::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse, written) == 24);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpTreeResponse, available) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest)
+ == ::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversRequest, output) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse)
+ == ::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse, written) == 24);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpDriversResponse, available) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest)
+ == ::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesRequest, output) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse)
+ == ::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse, written) == 24);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DebugDumper::DumpBindingPropertiesResponse, available) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Administrator::SuspendRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Administrator::SuspendRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Administrator::SuspendRequest)
+ == ::llcpp::fuchsia::device::manager::Administrator::SuspendRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Administrator::SuspendRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Administrator::SuspendResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Administrator::SuspendResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Administrator::SuspendResponse)
+ == ::llcpp::fuchsia::device::manager::Administrator::SuspendResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Administrator::SuspendResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest)
+ == ::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, coordinator_rpc) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, device_controller_rpc) == 20);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, protocol_id) == 24);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceStubRequest, local_device_id) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest)
+ == ::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, coordinator_rpc) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, device_controller_rpc) == 20);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, driver_path) == 24);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, driver) == 40);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, parent_proxy) == 44);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, proxy_args) == 48);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateDeviceRequest, local_device_id) == 64);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest)
+ == ::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, coordinator_rpc) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, device_controller_rpc) == 20);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, components) == 24);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, name) == 40);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceRequest, local_device_id) == 56);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceResponse)
+ == ::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DevhostController::CreateCompositeDeviceResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response, local_device_id) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response) == ::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_AddDevice_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response, local_device_id) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response) == ::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_AddDeviceInvisible_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceMetadata> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceMetadata>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceMetadata, key) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceMetadata, data) == 8);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceMetadata) == ::llcpp::fuchsia::device::manager::DeviceMetadata::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response) == ::llcpp::fuchsia::device::manager::DeviceController_Unbind_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceController_Unbind_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response) == ::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceController_CompleteRemoval_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response) == ::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_RunCompatibilityTests_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response) == ::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_PublishMetadata_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response) == ::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_MakeVisible_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response, vmo) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response, size) == 8);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response) == ::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_LoadFirmware_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response, path) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response) == ::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_GetTopologicalPath_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response, data) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response) == ::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_GetMetadata_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response, size) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response) == ::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_GetMetadataSize_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response) == ::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_DirectoryWatch_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response) == ::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_BindDevice_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response) == ::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_AddMetadata_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response) == ::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::Coordinator_AddCompositeDevice_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest)
+ == ::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest, driver_path) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverRequest, driver) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse)
+ == ::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::BindDriverResponse, test_output) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest)
+ == ::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::ConnectProxyRequest, shadow) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::InitResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::InitResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::InitResponse)
+ == ::llcpp::fuchsia::device::manager::DeviceController::InitResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::InitResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::UnbindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::UnbindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::UnbindResponse)
+ == ::llcpp::fuchsia::device::manager::DeviceController::UnbindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::UnbindResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::CompleteRemovalResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::CompleteRemovalResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::CompleteRemovalResponse)
+ == ::llcpp::fuchsia::device::manager::DeviceController::CompleteRemovalResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::CompleteRemovalResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::SuspendRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::SuspendRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::SuspendRequest)
+ == ::llcpp::fuchsia::device::manager::DeviceController::SuspendRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::SuspendRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::SuspendResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::SuspendResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::SuspendResponse)
+ == ::llcpp::fuchsia::device::manager::DeviceController::SuspendResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::SuspendResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::ResumeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::ResumeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::ResumeRequest)
+ == ::llcpp::fuchsia::device::manager::DeviceController::ResumeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::ResumeRequest, target_system_state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::ResumeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::ResumeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::ResumeResponse)
+ == ::llcpp::fuchsia::device::manager::DeviceController::ResumeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::ResumeResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceController::CompleteCompatibilityTestsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::DeviceController::CompleteCompatibilityTestsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceController::CompleteCompatibilityTestsRequest)
+ == ::llcpp::fuchsia::device::manager::DeviceController::CompleteCompatibilityTestsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceController::CompleteCompatibilityTestsRequest, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::BindInstruction> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::BindInstruction>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::BindInstruction, op) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::BindInstruction, arg) == 4);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::BindInstruction) == ::llcpp::fuchsia::device::manager::BindInstruction::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceComponentPart> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceComponentPart>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceComponentPart, match_program_count) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceComponentPart, match_program) == 4);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceComponentPart) == ::llcpp::fuchsia::device::manager::DeviceComponentPart::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::DeviceComponent> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::DeviceComponent>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceComponent, parts_count) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::DeviceComponent, parts) == 4);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::DeviceComponent) == ::llcpp::fuchsia::device::manager::DeviceComponent::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor>);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor, props) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor, components) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor, coresident_device_index) == 32);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor, metadata) == 40);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor) == ::llcpp::fuchsia::device::manager::CompositeDeviceDescriptor::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::AddDeviceConfig> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::manager::AddDeviceConfig>);
+static_assert(sizeof(::llcpp::fuchsia::device::manager::AddDeviceConfig) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, coordinator) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, device_controller) == 20);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, props) == 24);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, name) == 40);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, protocol_id) == 56);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, driver_path) == 64);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, args) == 80);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, device_add_config) == 96);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, has_init) == 100);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceRequest, client_remote) == 104);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::AddDeviceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, coordinator) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, device_controller) == 20);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, props) == 24);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, name) == 40);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, protocol_id) == 56);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, driver_path) == 64);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, args) == 80);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, has_init) == 96);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleRequest, client_remote) == 100);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddDeviceInvisibleResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::ScheduleRemoveRequest, unbind_self) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::MakeVisibleResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::MakeVisibleResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::MakeVisibleResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::MakeVisibleResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::MakeVisibleResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::BindDeviceRequest, driver_path) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::BindDeviceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::BindDeviceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::BindDeviceResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::BindDeviceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::BindDeviceResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::GetTopologicalPathResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::GetTopologicalPathResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::GetTopologicalPathResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::GetTopologicalPathResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::GetTopologicalPathResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareRequest, fw_path) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::LoadFirmwareResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataRequest, key) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::GetMetadataResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeRequest, key) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::GetMetadataSizeResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest, key) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddMetadataRequest, data) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddMetadataResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddMetadataResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddMetadataResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::AddMetadataResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddMetadataResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest, device_path) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest, key) == 32);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataRequest, data) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::PublishMetadataResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest, name) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceRequest, comp_desc) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::AddCompositeDeviceResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest, mask) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest, options) == 20);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchRequest, watcher) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::DirectoryWatchResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsRequest)
+ == ::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsRequest, hook_wait_time) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsResponse)
+ == ::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::manager::Coordinator::RunCompatibilityTestsResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-device/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-device/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..5bee540
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-device/gen/llcpp/fidl.cc
@@ -0,0 +1,2889 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/device/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+
+void ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(NameProvider_GetDeviceName_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(NameProvider_GetDeviceName_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(NameProvider_GetDeviceName_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kNameProvider_GetDeviceName_Ordinal = 0x980ac2500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNameProvider_GetDeviceName_GenOrdinal = 0x6030de8d2052b2celu;
+extern "C" const fidl_type_t v1_fuchsia_device_NameProviderGetDeviceNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_NameProviderGetDeviceNameResponseTable;
+
+} // namespace
+template <>
+NameProvider::ResultOf::GetDeviceName_Impl<NameProvider::GetDeviceNameResponse>::GetDeviceName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDeviceNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceNameRequest));
+ ::fidl::DecodedMessage<GetDeviceNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ NameProvider::InPlace::GetDeviceName(std::move(_client_end), Super::response_buffer()));
+}
+
+NameProvider::ResultOf::GetDeviceName NameProvider::SyncClient::GetDeviceName() {
+ return ResultOf::GetDeviceName(::zx::unowned_channel(this->channel_));
+}
+
+NameProvider::ResultOf::GetDeviceName NameProvider::Call::GetDeviceName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDeviceName(std::move(_client_end));
+}
+
+template <>
+NameProvider::UnownedResultOf::GetDeviceName_Impl<NameProvider::GetDeviceNameResponse>::GetDeviceName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDeviceNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDeviceNameRequest));
+ ::fidl::DecodedMessage<GetDeviceNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ NameProvider::InPlace::GetDeviceName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+NameProvider::UnownedResultOf::GetDeviceName NameProvider::SyncClient::GetDeviceName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+NameProvider::UnownedResultOf::GetDeviceName NameProvider::Call::GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<NameProvider::GetDeviceNameResponse> NameProvider::InPlace::GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDeviceNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDeviceNameRequest> params(std::move(_request_buffer));
+ NameProvider::SetTransactionHeaderFor::GetDeviceNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NameProvider::GetDeviceNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDeviceNameRequest, GetDeviceNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NameProvider::GetDeviceNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool NameProvider::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kNameProvider_GetDeviceName_Ordinal:
+ case kNameProvider_GetDeviceName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDeviceNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDeviceName(
+ Interface::GetDeviceNameCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool NameProvider::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void NameProvider::Interface::GetDeviceNameCompleterBase::Reply(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetDeviceNameResponse _response = {};
+ NameProvider::SetTransactionHeaderFor::GetDeviceNameResponse(
+ ::fidl::DecodedMessage<GetDeviceNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceNameResponse::PrimarySize,
+ GetDeviceNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NameProvider::Interface::GetDeviceNameCompleterBase::ReplySuccess(::fidl::StringView name) {
+ NameProvider_GetDeviceName_Response response;
+ response.name = std::move(name);
+
+ Reply(NameProvider_GetDeviceName_Result::WithResponse(&response));
+}
+void NameProvider::Interface::GetDeviceNameCompleterBase::ReplyError(int32_t error) {
+ Reply(NameProvider_GetDeviceName_Result::WithErr(&error));
+}
+
+void NameProvider::Interface::GetDeviceNameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result result) {
+ if (_buffer.capacity() < GetDeviceNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDeviceNameResponse _response = {};
+ NameProvider::SetTransactionHeaderFor::GetDeviceNameResponse(
+ ::fidl::DecodedMessage<GetDeviceNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceNameResponse::PrimarySize,
+ GetDeviceNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NameProvider::Interface::GetDeviceNameCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView name) {
+ NameProvider_GetDeviceName_Response response;
+ response.name = std::move(name);
+
+ Reply(std::move(_buffer), NameProvider_GetDeviceName_Result::WithResponse(&response));
+}
+
+void NameProvider::Interface::GetDeviceNameCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceNameResponse> params) {
+ NameProvider::SetTransactionHeaderFor::GetDeviceNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void NameProvider::SetTransactionHeaderFor::GetDeviceNameRequest(const ::fidl::DecodedMessage<NameProvider::GetDeviceNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNameProvider_GetDeviceName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void NameProvider::SetTransactionHeaderFor::GetDeviceNameResponse(const ::fidl::DecodedMessage<NameProvider::GetDeviceNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNameProvider_GetDeviceName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_GetPowerStateMapping_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_GetPowerStateMapping_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_GetPowerStateMapping_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_GetDevicePowerCaps_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_GetDevicePowerCaps_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_GetDevicePowerCaps_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::Controller_Resume_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_Resume_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_Resume_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_Resume_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+const char DEFAULT_DEVICE_NAME[] = "fuchsia";
+
+void ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_UpdatePowerStateMapping_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_UpdatePowerStateMapping_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_UpdatePowerStateMapping_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_ScheduleUnbind_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_ScheduleUnbind_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_ScheduleUnbind_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::Controller_Rebind_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_Rebind_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_Rebind_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_Rebind_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_GetTopologicalPath_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_GetTopologicalPath_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_GetTopologicalPath_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::device::Controller_Bind_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_Bind_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_Bind_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_Bind_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kController_Bind_Ordinal = 0x30b1cd5d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Bind_GenOrdinal = 0x3388f12801462769lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerBindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Rebind_Ordinal = 0x661b1f200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Rebind_GenOrdinal = 0x384fb80cbc2782e2lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerRebindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerRebindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ScheduleUnbind_Ordinal = 0xd0cd4ba00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ScheduleUnbind_GenOrdinal = 0x6128ba9d76aff9clu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerScheduleUnbindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerScheduleUnbindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDriverName_Ordinal = 0x76995acd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDriverName_GenOrdinal = 0x26f6ecf97738afe8lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDeviceName_Ordinal = 0x377a34e000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDeviceName_GenOrdinal = 0x69220024bb341abelu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDeviceNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDeviceNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetTopologicalPath_Ordinal = 0x430fc2d600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetTopologicalPath_GenOrdinal = 0x2689b37663e00788lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetTopologicalPathRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetTopologicalPathResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetEventHandle_Ordinal = 0x73cacb3600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetEventHandle_GenOrdinal = 0x60b4bf1536cb0ef4lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetEventHandleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetEventHandleResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDriverLogFlags_Ordinal = 0x5c5b709300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDriverLogFlags_GenOrdinal = 0x7272c2cf685f4b16lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverLogFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverLogFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetDriverLogFlags_Ordinal = 0x7d56732b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetDriverLogFlags_GenOrdinal = 0x45a98c40a24b8cf0lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetDriverLogFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetDriverLogFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_DebugResume_Ordinal = 0x5fee29c400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_DebugResume_GenOrdinal = 0xe1555cdd68b40e6lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerDebugResumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerDebugResumeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_RunCompatibilityTests_Ordinal = 0x484cd9af00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_RunCompatibilityTests_GenOrdinal = 0x58268c9ba1dc54d1lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerRunCompatibilityTestsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerRunCompatibilityTestsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDevicePowerCaps_Ordinal = 0x70a9ecf200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDevicePowerCaps_GenOrdinal = 0x19acb37026ae22dlu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePowerCapsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePowerCapsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDevicePerformanceStates_Ordinal = 0x388bd0d000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetDevicePerformanceStates_GenOrdinal = 0x24890b74e37f3e62lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePerformanceStatesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePerformanceStatesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_UpdatePowerStateMapping_Ordinal = 0x5200982600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_UpdatePowerStateMapping_GenOrdinal = 0x185489481614d7a6lu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerUpdatePowerStateMappingRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerUpdatePowerStateMappingResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetPowerStateMapping_Ordinal = 0x4ca6662900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetPowerStateMapping_GenOrdinal = 0x1a509f4010ee5cbelu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetPowerStateMappingRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetPowerStateMappingResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Suspend_Ordinal = 0x5897568300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Suspend_GenOrdinal = 0x6af131a48f7c8fdalu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSuspendResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Resume_Ordinal = 0x363da84d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Resume_GenOrdinal = 0x22c86261fd50a61elu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerResumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerResumeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetPerformanceState_Ordinal = 0x37f0cb1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetPerformanceState_GenOrdinal = 0x364c4698975d7f7clu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetPerformanceStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetPerformanceStateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ConfigureAutoSuspend_Ordinal = 0x6277961100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ConfigureAutoSuspend_GenOrdinal = 0x21dd7803b96694celu;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerConfigureAutoSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerConfigureAutoSuspendResponseTable;
+
+} // namespace
+template <>
+Controller::ResultOf::Bind_Impl<Controller::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ BindRequest _request = {};
+ _request.driver = std::move(driver);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Controller::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::Bind Controller::SyncClient::Bind(::fidl::StringView driver) {
+ return ResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(driver));
+}
+
+Controller::ResultOf::Bind Controller::Call::Bind(::zx::unowned_channel _client_end, ::fidl::StringView driver) {
+ return ResultOf::Bind(std::move(_client_end), std::move(driver));
+}
+
+template <>
+Controller::UnownedResultOf::Bind_Impl<Controller::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BindRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BindResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ BindRequest _request = {};
+ _request.driver = std::move(driver);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Controller::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::Bind Controller::SyncClient::Bind(::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(driver), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::Bind Controller::Call::Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(std::move(_client_end), std::move(_request_buffer), std::move(driver), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::BindResponse> Controller::InPlace::Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::BindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::BindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BindRequest, BindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::BindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Rebind_Impl<Controller::RebindResponse>::Rebind_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RebindRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ RebindRequest _request = {};
+ _request.driver = std::move(driver);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RebindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Controller::InPlace::Rebind(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::Rebind Controller::SyncClient::Rebind(::fidl::StringView driver) {
+ return ResultOf::Rebind(::zx::unowned_channel(this->channel_), std::move(driver));
+}
+
+Controller::ResultOf::Rebind Controller::Call::Rebind(::zx::unowned_channel _client_end, ::fidl::StringView driver) {
+ return ResultOf::Rebind(std::move(_client_end), std::move(driver));
+}
+
+template <>
+Controller::UnownedResultOf::Rebind_Impl<Controller::RebindResponse>::Rebind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RebindRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RebindResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ RebindRequest _request = {};
+ _request.driver = std::move(driver);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RebindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Controller::InPlace::Rebind(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::Rebind Controller::SyncClient::Rebind(::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rebind(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(driver), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::Rebind Controller::Call::Rebind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rebind(std::move(_client_end), std::move(_request_buffer), std::move(driver), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::RebindResponse> Controller::InPlace::Rebind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RebindRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::RebindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::RebindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RebindRequest, RebindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::RebindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::ScheduleUnbind_Impl<Controller::ScheduleUnbindResponse>::ScheduleUnbind_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleUnbindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ScheduleUnbindRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ScheduleUnbindRequest));
+ ::fidl::DecodedMessage<ScheduleUnbindRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::ScheduleUnbind(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::ScheduleUnbind Controller::SyncClient::ScheduleUnbind() {
+ return ResultOf::ScheduleUnbind(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::ScheduleUnbind Controller::Call::ScheduleUnbind(::zx::unowned_channel _client_end) {
+ return ResultOf::ScheduleUnbind(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::ScheduleUnbind_Impl<Controller::ScheduleUnbindResponse>::ScheduleUnbind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ScheduleUnbindRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ScheduleUnbindRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ScheduleUnbindRequest));
+ ::fidl::DecodedMessage<ScheduleUnbindRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::ScheduleUnbind(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::ScheduleUnbind Controller::SyncClient::ScheduleUnbind(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduleUnbind(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::ScheduleUnbind Controller::Call::ScheduleUnbind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ScheduleUnbind(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ScheduleUnbindResponse> Controller::InPlace::ScheduleUnbind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ScheduleUnbindRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ScheduleUnbindRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::ScheduleUnbindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ScheduleUnbindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ScheduleUnbindRequest, ScheduleUnbindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ScheduleUnbindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetDriverName_Impl<Controller::GetDriverNameResponse>::GetDriverName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDriverNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDriverNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDriverNameRequest));
+ ::fidl::DecodedMessage<GetDriverNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetDriverName(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetDriverName Controller::SyncClient::GetDriverName() {
+ return ResultOf::GetDriverName(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetDriverName Controller::Call::GetDriverName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDriverName(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetDriverName_Impl<Controller::GetDriverNameResponse>::GetDriverName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDriverNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDriverNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDriverNameRequest));
+ ::fidl::DecodedMessage<GetDriverNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetDriverName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetDriverName Controller::SyncClient::GetDriverName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDriverName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetDriverName Controller::Call::GetDriverName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDriverName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetDriverNameResponse> Controller::InPlace::GetDriverName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDriverNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDriverNameRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetDriverNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDriverNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDriverNameRequest, GetDriverNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDriverNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetDeviceName_Impl<Controller::GetDeviceNameResponse>::GetDeviceName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDeviceNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceNameRequest));
+ ::fidl::DecodedMessage<GetDeviceNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetDeviceName(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetDeviceName Controller::SyncClient::GetDeviceName() {
+ return ResultOf::GetDeviceName(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetDeviceName Controller::Call::GetDeviceName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDeviceName(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetDeviceName_Impl<Controller::GetDeviceNameResponse>::GetDeviceName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDeviceNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDeviceNameRequest));
+ ::fidl::DecodedMessage<GetDeviceNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetDeviceName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetDeviceName Controller::SyncClient::GetDeviceName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetDeviceName Controller::Call::GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetDeviceNameResponse> Controller::InPlace::GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDeviceNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDeviceNameRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetDeviceNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDeviceNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDeviceNameRequest, GetDeviceNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDeviceNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetTopologicalPath_Impl<Controller::GetTopologicalPathResponse>::GetTopologicalPath_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTopologicalPathRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTopologicalPathRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTopologicalPathRequest));
+ ::fidl::DecodedMessage<GetTopologicalPathRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetTopologicalPath(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetTopologicalPath Controller::SyncClient::GetTopologicalPath() {
+ return ResultOf::GetTopologicalPath(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetTopologicalPath Controller::Call::GetTopologicalPath(::zx::unowned_channel _client_end) {
+ return ResultOf::GetTopologicalPath(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetTopologicalPath_Impl<Controller::GetTopologicalPathResponse>::GetTopologicalPath_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTopologicalPathRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTopologicalPathRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTopologicalPathRequest));
+ ::fidl::DecodedMessage<GetTopologicalPathRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetTopologicalPath(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetTopologicalPath Controller::SyncClient::GetTopologicalPath(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTopologicalPath(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetTopologicalPath Controller::Call::GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTopologicalPath(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetTopologicalPathResponse> Controller::InPlace::GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTopologicalPathRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTopologicalPathRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetTopologicalPathRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetTopologicalPathResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTopologicalPathRequest, GetTopologicalPathResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetTopologicalPathResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetEventHandle_Impl<Controller::GetEventHandleResponse>::GetEventHandle_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetEventHandleRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetEventHandleRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetEventHandleRequest));
+ ::fidl::DecodedMessage<GetEventHandleRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetEventHandle(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetEventHandle Controller::SyncClient::GetEventHandle() {
+ return ResultOf::GetEventHandle(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetEventHandle Controller::Call::GetEventHandle(::zx::unowned_channel _client_end) {
+ return ResultOf::GetEventHandle(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetEventHandle_Impl<Controller::GetEventHandleResponse>::GetEventHandle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetEventHandleRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetEventHandleRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetEventHandleRequest));
+ ::fidl::DecodedMessage<GetEventHandleRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetEventHandle(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetEventHandle Controller::SyncClient::GetEventHandle(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetEventHandle(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetEventHandle Controller::Call::GetEventHandle(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetEventHandle(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetEventHandleResponse> Controller::InPlace::GetEventHandle(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetEventHandleRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetEventHandleRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetEventHandleRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetEventHandleResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetEventHandleRequest, GetEventHandleResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetEventHandleResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetDriverLogFlags_Impl<Controller::GetDriverLogFlagsResponse>::GetDriverLogFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDriverLogFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDriverLogFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDriverLogFlagsRequest));
+ ::fidl::DecodedMessage<GetDriverLogFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetDriverLogFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetDriverLogFlags Controller::SyncClient::GetDriverLogFlags() {
+ return ResultOf::GetDriverLogFlags(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetDriverLogFlags Controller::Call::GetDriverLogFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDriverLogFlags(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetDriverLogFlags_Impl<Controller::GetDriverLogFlagsResponse>::GetDriverLogFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDriverLogFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDriverLogFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDriverLogFlagsRequest));
+ ::fidl::DecodedMessage<GetDriverLogFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetDriverLogFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetDriverLogFlags Controller::SyncClient::GetDriverLogFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDriverLogFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetDriverLogFlags Controller::Call::GetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDriverLogFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetDriverLogFlagsResponse> Controller::InPlace::GetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDriverLogFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDriverLogFlagsRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetDriverLogFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDriverLogFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDriverLogFlagsRequest, GetDriverLogFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDriverLogFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::SetDriverLogFlags_Impl<Controller::SetDriverLogFlagsResponse>::SetDriverLogFlags_Impl(::zx::unowned_channel _client_end, uint32_t clear_flags, uint32_t set_flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetDriverLogFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetDriverLogFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetDriverLogFlagsRequest*>(_write_bytes);
+ _request.clear_flags = std::move(clear_flags);
+ _request.set_flags = std::move(set_flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetDriverLogFlagsRequest));
+ ::fidl::DecodedMessage<SetDriverLogFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::SetDriverLogFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::SetDriverLogFlags Controller::SyncClient::SetDriverLogFlags(uint32_t clear_flags, uint32_t set_flags) {
+ return ResultOf::SetDriverLogFlags(::zx::unowned_channel(this->channel_), std::move(clear_flags), std::move(set_flags));
+}
+
+Controller::ResultOf::SetDriverLogFlags Controller::Call::SetDriverLogFlags(::zx::unowned_channel _client_end, uint32_t clear_flags, uint32_t set_flags) {
+ return ResultOf::SetDriverLogFlags(std::move(_client_end), std::move(clear_flags), std::move(set_flags));
+}
+
+template <>
+Controller::UnownedResultOf::SetDriverLogFlags_Impl<Controller::SetDriverLogFlagsResponse>::SetDriverLogFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetDriverLogFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetDriverLogFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetDriverLogFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetDriverLogFlagsRequest*>(_request_buffer.data());
+ _request.clear_flags = std::move(clear_flags);
+ _request.set_flags = std::move(set_flags);
+ _request_buffer.set_actual(sizeof(SetDriverLogFlagsRequest));
+ ::fidl::DecodedMessage<SetDriverLogFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::SetDriverLogFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::SetDriverLogFlags Controller::SyncClient::SetDriverLogFlags(::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetDriverLogFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(clear_flags), std::move(set_flags), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::SetDriverLogFlags Controller::Call::SetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetDriverLogFlags(std::move(_client_end), std::move(_request_buffer), std::move(clear_flags), std::move(set_flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::SetDriverLogFlagsResponse> Controller::InPlace::SetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDriverLogFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::SetDriverLogFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::SetDriverLogFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetDriverLogFlagsRequest, SetDriverLogFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::SetDriverLogFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::DebugResume_Impl<Controller::DebugResumeResponse>::DebugResume_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DebugResumeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DebugResumeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DebugResumeRequest));
+ ::fidl::DecodedMessage<DebugResumeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::DebugResume(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::DebugResume Controller::SyncClient::DebugResume() {
+ return ResultOf::DebugResume(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::DebugResume Controller::Call::DebugResume(::zx::unowned_channel _client_end) {
+ return ResultOf::DebugResume(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::DebugResume_Impl<Controller::DebugResumeResponse>::DebugResume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DebugResumeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DebugResumeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DebugResumeRequest));
+ ::fidl::DecodedMessage<DebugResumeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::DebugResume(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::DebugResume Controller::SyncClient::DebugResume(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DebugResume(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::DebugResume Controller::Call::DebugResume(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DebugResume(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::DebugResumeResponse> Controller::InPlace::DebugResume(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DebugResumeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DebugResumeRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::DebugResumeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::DebugResumeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DebugResumeRequest, DebugResumeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::DebugResumeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::RunCompatibilityTests_Impl<Controller::RunCompatibilityTestsResponse>::RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, int64_t hook_wait_time) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RunCompatibilityTestsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RunCompatibilityTestsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RunCompatibilityTestsRequest*>(_write_bytes);
+ _request.hook_wait_time = std::move(hook_wait_time);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RunCompatibilityTestsRequest));
+ ::fidl::DecodedMessage<RunCompatibilityTestsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::RunCompatibilityTests(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::RunCompatibilityTests Controller::SyncClient::RunCompatibilityTests(int64_t hook_wait_time) {
+ return ResultOf::RunCompatibilityTests(::zx::unowned_channel(this->channel_), std::move(hook_wait_time));
+}
+
+Controller::ResultOf::RunCompatibilityTests Controller::Call::RunCompatibilityTests(::zx::unowned_channel _client_end, int64_t hook_wait_time) {
+ return ResultOf::RunCompatibilityTests(std::move(_client_end), std::move(hook_wait_time));
+}
+
+template <>
+Controller::UnownedResultOf::RunCompatibilityTests_Impl<Controller::RunCompatibilityTestsResponse>::RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RunCompatibilityTestsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RunCompatibilityTestsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RunCompatibilityTestsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RunCompatibilityTestsRequest*>(_request_buffer.data());
+ _request.hook_wait_time = std::move(hook_wait_time);
+ _request_buffer.set_actual(sizeof(RunCompatibilityTestsRequest));
+ ::fidl::DecodedMessage<RunCompatibilityTestsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::RunCompatibilityTests(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::RunCompatibilityTests Controller::SyncClient::RunCompatibilityTests(::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RunCompatibilityTests(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(hook_wait_time), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::RunCompatibilityTests Controller::Call::RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RunCompatibilityTests(std::move(_client_end), std::move(_request_buffer), std::move(hook_wait_time), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::RunCompatibilityTestsResponse> Controller::InPlace::RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RunCompatibilityTestsRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::RunCompatibilityTestsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::RunCompatibilityTestsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RunCompatibilityTestsRequest, RunCompatibilityTestsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::RunCompatibilityTestsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetDevicePowerCaps_Impl<Controller::GetDevicePowerCapsResponse>::GetDevicePowerCaps_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDevicePowerCapsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDevicePowerCapsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDevicePowerCapsRequest));
+ ::fidl::DecodedMessage<GetDevicePowerCapsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetDevicePowerCaps(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetDevicePowerCaps Controller::SyncClient::GetDevicePowerCaps() {
+ return ResultOf::GetDevicePowerCaps(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetDevicePowerCaps Controller::Call::GetDevicePowerCaps(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDevicePowerCaps(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetDevicePowerCaps_Impl<Controller::GetDevicePowerCapsResponse>::GetDevicePowerCaps_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDevicePowerCapsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDevicePowerCapsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDevicePowerCapsRequest));
+ ::fidl::DecodedMessage<GetDevicePowerCapsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetDevicePowerCaps(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetDevicePowerCaps Controller::SyncClient::GetDevicePowerCaps(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDevicePowerCaps(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetDevicePowerCaps Controller::Call::GetDevicePowerCaps(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDevicePowerCaps(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetDevicePowerCapsResponse> Controller::InPlace::GetDevicePowerCaps(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDevicePowerCapsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDevicePowerCapsRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetDevicePowerCapsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDevicePowerCapsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDevicePowerCapsRequest, GetDevicePowerCapsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDevicePowerCapsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetDevicePerformanceStates_Impl<Controller::GetDevicePerformanceStatesResponse>::GetDevicePerformanceStates_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDevicePerformanceStatesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDevicePerformanceStatesRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDevicePerformanceStatesRequest));
+ ::fidl::DecodedMessage<GetDevicePerformanceStatesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetDevicePerformanceStates(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetDevicePerformanceStates Controller::SyncClient::GetDevicePerformanceStates() {
+ return ResultOf::GetDevicePerformanceStates(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetDevicePerformanceStates Controller::Call::GetDevicePerformanceStates(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDevicePerformanceStates(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetDevicePerformanceStates_Impl<Controller::GetDevicePerformanceStatesResponse>::GetDevicePerformanceStates_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDevicePerformanceStatesRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDevicePerformanceStatesRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDevicePerformanceStatesRequest));
+ ::fidl::DecodedMessage<GetDevicePerformanceStatesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetDevicePerformanceStates(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetDevicePerformanceStates Controller::SyncClient::GetDevicePerformanceStates(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDevicePerformanceStates(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetDevicePerformanceStates Controller::Call::GetDevicePerformanceStates(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDevicePerformanceStates(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetDevicePerformanceStatesResponse> Controller::InPlace::GetDevicePerformanceStates(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDevicePerformanceStatesRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDevicePerformanceStatesRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetDevicePerformanceStatesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDevicePerformanceStatesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDevicePerformanceStatesRequest, GetDevicePerformanceStatesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetDevicePerformanceStatesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::UpdatePowerStateMapping_Impl<Controller::UpdatePowerStateMappingResponse>::UpdatePowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdatePowerStateMappingRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, UpdatePowerStateMappingRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<UpdatePowerStateMappingRequest*>(_write_bytes);
+ _request.mapping = std::move(mapping);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UpdatePowerStateMappingRequest));
+ ::fidl::DecodedMessage<UpdatePowerStateMappingRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::UpdatePowerStateMapping(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::UpdatePowerStateMapping Controller::SyncClient::UpdatePowerStateMapping(::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping) {
+ return ResultOf::UpdatePowerStateMapping(::zx::unowned_channel(this->channel_), std::move(mapping));
+}
+
+Controller::ResultOf::UpdatePowerStateMapping Controller::Call::UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping) {
+ return ResultOf::UpdatePowerStateMapping(std::move(_client_end), std::move(mapping));
+}
+
+template <>
+Controller::UnownedResultOf::UpdatePowerStateMapping_Impl<Controller::UpdatePowerStateMappingResponse>::UpdatePowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UpdatePowerStateMappingRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UpdatePowerStateMappingResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, UpdatePowerStateMappingRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<UpdatePowerStateMappingRequest*>(_request_buffer.data());
+ _request.mapping = std::move(mapping);
+ _request_buffer.set_actual(sizeof(UpdatePowerStateMappingRequest));
+ ::fidl::DecodedMessage<UpdatePowerStateMappingRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::UpdatePowerStateMapping(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::UpdatePowerStateMapping Controller::SyncClient::UpdatePowerStateMapping(::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdatePowerStateMapping(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mapping), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::UpdatePowerStateMapping Controller::Call::UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdatePowerStateMapping(std::move(_client_end), std::move(_request_buffer), std::move(mapping), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::UpdatePowerStateMappingResponse> Controller::InPlace::UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdatePowerStateMappingRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::UpdatePowerStateMappingRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::UpdatePowerStateMappingResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UpdatePowerStateMappingRequest, UpdatePowerStateMappingResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::UpdatePowerStateMappingResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetPowerStateMapping_Impl<Controller::GetPowerStateMappingResponse>::GetPowerStateMapping_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPowerStateMappingRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPowerStateMappingRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPowerStateMappingRequest));
+ ::fidl::DecodedMessage<GetPowerStateMappingRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetPowerStateMapping(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetPowerStateMapping Controller::SyncClient::GetPowerStateMapping() {
+ return ResultOf::GetPowerStateMapping(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetPowerStateMapping Controller::Call::GetPowerStateMapping(::zx::unowned_channel _client_end) {
+ return ResultOf::GetPowerStateMapping(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetPowerStateMapping_Impl<Controller::GetPowerStateMappingResponse>::GetPowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPowerStateMappingRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPowerStateMappingRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPowerStateMappingRequest));
+ ::fidl::DecodedMessage<GetPowerStateMappingRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetPowerStateMapping(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetPowerStateMapping Controller::SyncClient::GetPowerStateMapping(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPowerStateMapping(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetPowerStateMapping Controller::Call::GetPowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPowerStateMapping(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetPowerStateMappingResponse> Controller::InPlace::GetPowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPowerStateMappingRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPowerStateMappingRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetPowerStateMappingRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetPowerStateMappingResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPowerStateMappingRequest, GetPowerStateMappingResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetPowerStateMappingResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Suspend_Impl<Controller::SuspendResponse>::Suspend_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendRequest*>(_write_bytes);
+ _request.requested_state = std::move(requested_state);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendRequest));
+ ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::Suspend Controller::SyncClient::Suspend(::llcpp::fuchsia::device::DevicePowerState requested_state) {
+ return ResultOf::Suspend(::zx::unowned_channel(this->channel_), std::move(requested_state));
+}
+
+Controller::ResultOf::Suspend Controller::Call::Suspend(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state) {
+ return ResultOf::Suspend(std::move(_client_end), std::move(requested_state));
+}
+
+template <>
+Controller::UnownedResultOf::Suspend_Impl<Controller::SuspendResponse>::Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SuspendRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SuspendRequest*>(_request_buffer.data());
+ _request.requested_state = std::move(requested_state);
+ _request_buffer.set_actual(sizeof(SuspendRequest));
+ ::fidl::DecodedMessage<SuspendRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::Suspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::Suspend Controller::SyncClient::Suspend(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Suspend(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(requested_state), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::Suspend Controller::Call::Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Suspend(std::move(_client_end), std::move(_request_buffer), std::move(requested_state), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::SuspendResponse> Controller::InPlace::Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::SuspendRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::SuspendResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SuspendRequest, SuspendResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::SuspendResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Resume_Impl<Controller::ResumeResponse>::Resume_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ResumeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ResumeRequest*>(_write_bytes);
+ _request.requested_state = std::move(requested_state);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResumeRequest));
+ ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::Resume Controller::SyncClient::Resume(::llcpp::fuchsia::device::DevicePowerState requested_state) {
+ return ResultOf::Resume(::zx::unowned_channel(this->channel_), std::move(requested_state));
+}
+
+Controller::ResultOf::Resume Controller::Call::Resume(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state) {
+ return ResultOf::Resume(std::move(_client_end), std::move(requested_state));
+}
+
+template <>
+Controller::UnownedResultOf::Resume_Impl<Controller::ResumeResponse>::Resume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ResumeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ResumeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ResumeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ResumeRequest*>(_request_buffer.data());
+ _request.requested_state = std::move(requested_state);
+ _request_buffer.set_actual(sizeof(ResumeRequest));
+ ::fidl::DecodedMessage<ResumeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::Resume(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::Resume Controller::SyncClient::Resume(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resume(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(requested_state), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::Resume Controller::Call::Resume(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resume(std::move(_client_end), std::move(_request_buffer), std::move(requested_state), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ResumeResponse> Controller::InPlace::Resume(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::ResumeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ResumeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ResumeRequest, ResumeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ResumeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::SetPerformanceState_Impl<Controller::SetPerformanceStateResponse>::SetPerformanceState_Impl(::zx::unowned_channel _client_end, uint32_t requested_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetPerformanceStateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetPerformanceStateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetPerformanceStateRequest*>(_write_bytes);
+ _request.requested_state = std::move(requested_state);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetPerformanceStateRequest));
+ ::fidl::DecodedMessage<SetPerformanceStateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::SetPerformanceState(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::SetPerformanceState Controller::SyncClient::SetPerformanceState(uint32_t requested_state) {
+ return ResultOf::SetPerformanceState(::zx::unowned_channel(this->channel_), std::move(requested_state));
+}
+
+Controller::ResultOf::SetPerformanceState Controller::Call::SetPerformanceState(::zx::unowned_channel _client_end, uint32_t requested_state) {
+ return ResultOf::SetPerformanceState(std::move(_client_end), std::move(requested_state));
+}
+
+template <>
+Controller::UnownedResultOf::SetPerformanceState_Impl<Controller::SetPerformanceStateResponse>::SetPerformanceState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetPerformanceStateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetPerformanceStateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetPerformanceStateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetPerformanceStateRequest*>(_request_buffer.data());
+ _request.requested_state = std::move(requested_state);
+ _request_buffer.set_actual(sizeof(SetPerformanceStateRequest));
+ ::fidl::DecodedMessage<SetPerformanceStateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::SetPerformanceState(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::SetPerformanceState Controller::SyncClient::SetPerformanceState(::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetPerformanceState(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(requested_state), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::SetPerformanceState Controller::Call::SetPerformanceState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetPerformanceState(std::move(_client_end), std::move(_request_buffer), std::move(requested_state), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::SetPerformanceStateResponse> Controller::InPlace::SetPerformanceState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPerformanceStateRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::SetPerformanceStateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::SetPerformanceStateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetPerformanceStateRequest, SetPerformanceStateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::SetPerformanceStateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::ConfigureAutoSuspend_Impl<Controller::ConfigureAutoSuspendResponse>::ConfigureAutoSuspend_Impl(::zx::unowned_channel _client_end, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigureAutoSuspendRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConfigureAutoSuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConfigureAutoSuspendRequest*>(_write_bytes);
+ _request.enable = std::move(enable);
+ _request.requested_deepest_sleep_state = std::move(requested_deepest_sleep_state);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigureAutoSuspendRequest));
+ ::fidl::DecodedMessage<ConfigureAutoSuspendRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::ConfigureAutoSuspend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::ConfigureAutoSuspend Controller::SyncClient::ConfigureAutoSuspend(bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state) {
+ return ResultOf::ConfigureAutoSuspend(::zx::unowned_channel(this->channel_), std::move(enable), std::move(requested_deepest_sleep_state));
+}
+
+Controller::ResultOf::ConfigureAutoSuspend Controller::Call::ConfigureAutoSuspend(::zx::unowned_channel _client_end, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state) {
+ return ResultOf::ConfigureAutoSuspend(std::move(_client_end), std::move(enable), std::move(requested_deepest_sleep_state));
+}
+
+template <>
+Controller::UnownedResultOf::ConfigureAutoSuspend_Impl<Controller::ConfigureAutoSuspendResponse>::ConfigureAutoSuspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConfigureAutoSuspendRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConfigureAutoSuspendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ConfigureAutoSuspendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConfigureAutoSuspendRequest*>(_request_buffer.data());
+ _request.enable = std::move(enable);
+ _request.requested_deepest_sleep_state = std::move(requested_deepest_sleep_state);
+ _request_buffer.set_actual(sizeof(ConfigureAutoSuspendRequest));
+ ::fidl::DecodedMessage<ConfigureAutoSuspendRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::ConfigureAutoSuspend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::ConfigureAutoSuspend Controller::SyncClient::ConfigureAutoSuspend(::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigureAutoSuspend(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(enable), std::move(requested_deepest_sleep_state), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::ConfigureAutoSuspend Controller::Call::ConfigureAutoSuspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigureAutoSuspend(std::move(_client_end), std::move(_request_buffer), std::move(enable), std::move(requested_deepest_sleep_state), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ConfigureAutoSuspendResponse> Controller::InPlace::ConfigureAutoSuspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigureAutoSuspendRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::ConfigureAutoSuspendRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ConfigureAutoSuspendResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConfigureAutoSuspendRequest, ConfigureAutoSuspendResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ConfigureAutoSuspendResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Controller::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kController_Bind_Ordinal:
+ case kController_Bind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Bind(std::move(message->driver),
+ Interface::BindCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Rebind_Ordinal:
+ case kController_Rebind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RebindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Rebind(std::move(message->driver),
+ Interface::RebindCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ScheduleUnbind_Ordinal:
+ case kController_ScheduleUnbind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ScheduleUnbindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ScheduleUnbind(
+ Interface::ScheduleUnbindCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetDriverName_Ordinal:
+ case kController_GetDriverName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDriverNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDriverName(
+ Interface::GetDriverNameCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetDeviceName_Ordinal:
+ case kController_GetDeviceName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDeviceNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDeviceName(
+ Interface::GetDeviceNameCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetTopologicalPath_Ordinal:
+ case kController_GetTopologicalPath_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTopologicalPathRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetTopologicalPath(
+ Interface::GetTopologicalPathCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetEventHandle_Ordinal:
+ case kController_GetEventHandle_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetEventHandleRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetEventHandle(
+ Interface::GetEventHandleCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetDriverLogFlags_Ordinal:
+ case kController_GetDriverLogFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDriverLogFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDriverLogFlags(
+ Interface::GetDriverLogFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetDriverLogFlags_Ordinal:
+ case kController_SetDriverLogFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetDriverLogFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetDriverLogFlags(std::move(message->clear_flags), std::move(message->set_flags),
+ Interface::SetDriverLogFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kController_DebugResume_Ordinal:
+ case kController_DebugResume_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DebugResumeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->DebugResume(
+ Interface::DebugResumeCompleter::Sync(txn));
+ return true;
+ }
+ case kController_RunCompatibilityTests_Ordinal:
+ case kController_RunCompatibilityTests_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RunCompatibilityTestsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RunCompatibilityTests(std::move(message->hook_wait_time),
+ Interface::RunCompatibilityTestsCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetDevicePowerCaps_Ordinal:
+ case kController_GetDevicePowerCaps_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDevicePowerCapsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDevicePowerCaps(
+ Interface::GetDevicePowerCapsCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetDevicePerformanceStates_Ordinal:
+ case kController_GetDevicePerformanceStates_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDevicePerformanceStatesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDevicePerformanceStates(
+ Interface::GetDevicePerformanceStatesCompleter::Sync(txn));
+ return true;
+ }
+ case kController_UpdatePowerStateMapping_Ordinal:
+ case kController_UpdatePowerStateMapping_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UpdatePowerStateMappingRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UpdatePowerStateMapping(std::move(message->mapping),
+ Interface::UpdatePowerStateMappingCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetPowerStateMapping_Ordinal:
+ case kController_GetPowerStateMapping_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPowerStateMappingRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetPowerStateMapping(
+ Interface::GetPowerStateMappingCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Suspend_Ordinal:
+ case kController_Suspend_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SuspendRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Suspend(std::move(message->requested_state),
+ Interface::SuspendCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Resume_Ordinal:
+ case kController_Resume_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ResumeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Resume(std::move(message->requested_state),
+ Interface::ResumeCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetPerformanceState_Ordinal:
+ case kController_SetPerformanceState_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetPerformanceStateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetPerformanceState(std::move(message->requested_state),
+ Interface::SetPerformanceStateCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ConfigureAutoSuspend_Ordinal:
+ case kController_ConfigureAutoSuspend_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConfigureAutoSuspendRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ConfigureAutoSuspend(std::move(message->enable), std::move(message->requested_deepest_sleep_state),
+ Interface::ConfigureAutoSuspendCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Controller::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Controller::Interface::BindCompleterBase::Reply(::llcpp::fuchsia::device::Controller_Bind_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ BindResponse _response = {};
+ Controller::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::BindCompleterBase::ReplySuccess() {
+ Controller_Bind_Response response;
+
+ Reply(Controller_Bind_Result::WithResponse(&response));
+}
+void Controller::Interface::BindCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_Bind_Result::WithErr(&error));
+}
+
+void Controller::Interface::BindCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Bind_Result result) {
+ if (_buffer.capacity() < BindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ BindResponse _response = {};
+ Controller::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::BindCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_Bind_Response response;
+
+ Reply(std::move(_buffer), Controller_Bind_Result::WithResponse(&response));
+}
+
+void Controller::Interface::BindCompleterBase::Reply(::fidl::DecodedMessage<BindResponse> params) {
+ Controller::SetTransactionHeaderFor::BindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::RebindCompleterBase::Reply(::llcpp::fuchsia::device::Controller_Rebind_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RebindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ RebindResponse _response = {};
+ Controller::SetTransactionHeaderFor::RebindResponse(
+ ::fidl::DecodedMessage<RebindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RebindResponse::PrimarySize,
+ RebindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::RebindCompleterBase::ReplySuccess() {
+ Controller_Rebind_Response response;
+
+ Reply(Controller_Rebind_Result::WithResponse(&response));
+}
+void Controller::Interface::RebindCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_Rebind_Result::WithErr(&error));
+}
+
+void Controller::Interface::RebindCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Rebind_Result result) {
+ if (_buffer.capacity() < RebindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RebindResponse _response = {};
+ Controller::SetTransactionHeaderFor::RebindResponse(
+ ::fidl::DecodedMessage<RebindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RebindResponse::PrimarySize,
+ RebindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::RebindCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_Rebind_Response response;
+
+ Reply(std::move(_buffer), Controller_Rebind_Result::WithResponse(&response));
+}
+
+void Controller::Interface::RebindCompleterBase::Reply(::fidl::DecodedMessage<RebindResponse> params) {
+ Controller::SetTransactionHeaderFor::RebindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::ScheduleUnbindCompleterBase::Reply(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ScheduleUnbindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ScheduleUnbindResponse _response = {};
+ Controller::SetTransactionHeaderFor::ScheduleUnbindResponse(
+ ::fidl::DecodedMessage<ScheduleUnbindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduleUnbindResponse::PrimarySize,
+ ScheduleUnbindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ScheduleUnbindCompleterBase::ReplySuccess() {
+ Controller_ScheduleUnbind_Response response;
+
+ Reply(Controller_ScheduleUnbind_Result::WithResponse(&response));
+}
+void Controller::Interface::ScheduleUnbindCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_ScheduleUnbind_Result::WithErr(&error));
+}
+
+void Controller::Interface::ScheduleUnbindCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result result) {
+ if (_buffer.capacity() < ScheduleUnbindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ScheduleUnbindResponse _response = {};
+ Controller::SetTransactionHeaderFor::ScheduleUnbindResponse(
+ ::fidl::DecodedMessage<ScheduleUnbindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ScheduleUnbindResponse::PrimarySize,
+ ScheduleUnbindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ScheduleUnbindCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_ScheduleUnbind_Response response;
+
+ Reply(std::move(_buffer), Controller_ScheduleUnbind_Result::WithResponse(&response));
+}
+
+void Controller::Interface::ScheduleUnbindCompleterBase::Reply(::fidl::DecodedMessage<ScheduleUnbindResponse> params) {
+ Controller::SetTransactionHeaderFor::ScheduleUnbindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetDriverNameCompleterBase::Reply(int32_t status, ::fidl::StringView name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDriverNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetDriverNameResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetDriverNameResponse(
+ ::fidl::DecodedMessage<GetDriverNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDriverNameResponse::PrimarySize,
+ GetDriverNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetDriverNameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::StringView name) {
+ if (_buffer.capacity() < GetDriverNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDriverNameResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetDriverNameResponse(
+ ::fidl::DecodedMessage<GetDriverNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDriverNameResponse::PrimarySize,
+ GetDriverNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetDriverNameCompleterBase::Reply(::fidl::DecodedMessage<GetDriverNameResponse> params) {
+ Controller::SetTransactionHeaderFor::GetDriverNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetDeviceNameCompleterBase::Reply(::fidl::StringView name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetDeviceNameResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetDeviceNameResponse(
+ ::fidl::DecodedMessage<GetDeviceNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceNameResponse::PrimarySize,
+ GetDeviceNameResponse::PrimarySize)));
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetDeviceNameCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::StringView name) {
+ if (_buffer.capacity() < GetDeviceNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDeviceNameResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetDeviceNameResponse(
+ ::fidl::DecodedMessage<GetDeviceNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceNameResponse::PrimarySize,
+ GetDeviceNameResponse::PrimarySize)));
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetDeviceNameCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceNameResponse> params) {
+ Controller::SetTransactionHeaderFor::GetDeviceNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetTopologicalPathCompleterBase::Reply(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTopologicalPathResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetTopologicalPathResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetTopologicalPathResponse(
+ ::fidl::DecodedMessage<GetTopologicalPathResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTopologicalPathResponse::PrimarySize,
+ GetTopologicalPathResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::GetTopologicalPathCompleterBase::ReplySuccess(::fidl::StringView path) {
+ Controller_GetTopologicalPath_Response response;
+ response.path = std::move(path);
+
+ Reply(Controller_GetTopologicalPath_Result::WithResponse(&response));
+}
+void Controller::Interface::GetTopologicalPathCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_GetTopologicalPath_Result::WithErr(&error));
+}
+
+void Controller::Interface::GetTopologicalPathCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result result) {
+ if (_buffer.capacity() < GetTopologicalPathResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTopologicalPathResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetTopologicalPathResponse(
+ ::fidl::DecodedMessage<GetTopologicalPathResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTopologicalPathResponse::PrimarySize,
+ GetTopologicalPathResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::GetTopologicalPathCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView path) {
+ Controller_GetTopologicalPath_Response response;
+ response.path = std::move(path);
+
+ Reply(std::move(_buffer), Controller_GetTopologicalPath_Result::WithResponse(&response));
+}
+
+void Controller::Interface::GetTopologicalPathCompleterBase::Reply(::fidl::DecodedMessage<GetTopologicalPathResponse> params) {
+ Controller::SetTransactionHeaderFor::GetTopologicalPathResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetEventHandleCompleterBase::Reply(int32_t status, ::zx::event event) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetEventHandleResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetEventHandleResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetEventHandleResponse(
+ ::fidl::DecodedMessage<GetEventHandleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetEventHandleResponse::PrimarySize,
+ GetEventHandleResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.event = std::move(event);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetEventHandleResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetEventHandleResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetEventHandleCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event event) {
+ if (_buffer.capacity() < GetEventHandleResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetEventHandleResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetEventHandleResponse(
+ ::fidl::DecodedMessage<GetEventHandleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetEventHandleResponse::PrimarySize,
+ GetEventHandleResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.event = std::move(event);
+ _buffer.set_actual(sizeof(GetEventHandleResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetEventHandleResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetEventHandleCompleterBase::Reply(::fidl::DecodedMessage<GetEventHandleResponse> params) {
+ Controller::SetTransactionHeaderFor::GetEventHandleResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetDriverLogFlagsCompleterBase::Reply(int32_t status, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDriverLogFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetDriverLogFlagsResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetDriverLogFlagsResponse(
+ ::fidl::DecodedMessage<GetDriverLogFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDriverLogFlagsResponse::PrimarySize,
+ GetDriverLogFlagsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDriverLogFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDriverLogFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetDriverLogFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint32_t flags) {
+ if (_buffer.capacity() < GetDriverLogFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetDriverLogFlagsResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetDriverLogFlagsResponse(
+ ::fidl::DecodedMessage<GetDriverLogFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDriverLogFlagsResponse::PrimarySize,
+ GetDriverLogFlagsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(GetDriverLogFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDriverLogFlagsResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetDriverLogFlagsCompleterBase::Reply(::fidl::DecodedMessage<GetDriverLogFlagsResponse> params) {
+ Controller::SetTransactionHeaderFor::GetDriverLogFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::SetDriverLogFlagsCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetDriverLogFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetDriverLogFlagsResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::SetDriverLogFlagsResponse(
+ ::fidl::DecodedMessage<SetDriverLogFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetDriverLogFlagsResponse::PrimarySize,
+ SetDriverLogFlagsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetDriverLogFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetDriverLogFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::SetDriverLogFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetDriverLogFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetDriverLogFlagsResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::SetDriverLogFlagsResponse(
+ ::fidl::DecodedMessage<SetDriverLogFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetDriverLogFlagsResponse::PrimarySize,
+ SetDriverLogFlagsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetDriverLogFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetDriverLogFlagsResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::SetDriverLogFlagsCompleterBase::Reply(::fidl::DecodedMessage<SetDriverLogFlagsResponse> params) {
+ Controller::SetTransactionHeaderFor::SetDriverLogFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::DebugResumeCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DebugResumeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DebugResumeResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::DebugResumeResponse(
+ ::fidl::DecodedMessage<DebugResumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DebugResumeResponse::PrimarySize,
+ DebugResumeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DebugResumeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DebugResumeResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::DebugResumeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < DebugResumeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DebugResumeResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::DebugResumeResponse(
+ ::fidl::DecodedMessage<DebugResumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DebugResumeResponse::PrimarySize,
+ DebugResumeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(DebugResumeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DebugResumeResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::DebugResumeCompleterBase::Reply(::fidl::DecodedMessage<DebugResumeResponse> params) {
+ Controller::SetTransactionHeaderFor::DebugResumeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::RunCompatibilityTestsCompleterBase::Reply(uint32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RunCompatibilityTestsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RunCompatibilityTestsResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::RunCompatibilityTestsResponse(
+ ::fidl::DecodedMessage<RunCompatibilityTestsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RunCompatibilityTestsResponse::PrimarySize,
+ RunCompatibilityTestsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RunCompatibilityTestsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RunCompatibilityTestsResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::RunCompatibilityTestsCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t status) {
+ if (_buffer.capacity() < RunCompatibilityTestsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RunCompatibilityTestsResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::RunCompatibilityTestsResponse(
+ ::fidl::DecodedMessage<RunCompatibilityTestsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RunCompatibilityTestsResponse::PrimarySize,
+ RunCompatibilityTestsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(RunCompatibilityTestsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RunCompatibilityTestsResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::RunCompatibilityTestsCompleterBase::Reply(::fidl::DecodedMessage<RunCompatibilityTestsResponse> params) {
+ Controller::SetTransactionHeaderFor::RunCompatibilityTestsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetDevicePowerCapsCompleterBase::Reply(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDevicePowerCapsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetDevicePowerCapsResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetDevicePowerCapsResponse(
+ ::fidl::DecodedMessage<GetDevicePowerCapsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDevicePowerCapsResponse::PrimarySize,
+ GetDevicePowerCapsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::GetDevicePowerCapsCompleterBase::ReplySuccess(::fidl::Array<::llcpp::fuchsia::device::DevicePowerStateInfo, 5> dpstates) {
+ Controller_GetDevicePowerCaps_Response response;
+ response.dpstates = std::move(dpstates);
+
+ Reply(Controller_GetDevicePowerCaps_Result::WithResponse(&response));
+}
+void Controller::Interface::GetDevicePowerCapsCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_GetDevicePowerCaps_Result::WithErr(&error));
+}
+
+void Controller::Interface::GetDevicePowerCapsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result result) {
+ if (_buffer.capacity() < GetDevicePowerCapsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDevicePowerCapsResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetDevicePowerCapsResponse(
+ ::fidl::DecodedMessage<GetDevicePowerCapsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDevicePowerCapsResponse::PrimarySize,
+ GetDevicePowerCapsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::GetDevicePowerCapsCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::DevicePowerStateInfo, 5> dpstates) {
+ Controller_GetDevicePowerCaps_Response response;
+ response.dpstates = std::move(dpstates);
+
+ Reply(std::move(_buffer), Controller_GetDevicePowerCaps_Result::WithResponse(&response));
+}
+
+void Controller::Interface::GetDevicePowerCapsCompleterBase::Reply(::fidl::DecodedMessage<GetDevicePowerCapsResponse> params) {
+ Controller::SetTransactionHeaderFor::GetDevicePowerCapsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetDevicePerformanceStatesCompleterBase::Reply(::fidl::Array<::llcpp::fuchsia::device::DevicePerformanceStateInfo, 20> states, int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDevicePerformanceStatesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetDevicePerformanceStatesResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetDevicePerformanceStatesResponse(
+ ::fidl::DecodedMessage<GetDevicePerformanceStatesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDevicePerformanceStatesResponse::PrimarySize,
+ GetDevicePerformanceStatesResponse::PrimarySize)));
+ _response.states = std::move(states);
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDevicePerformanceStatesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDevicePerformanceStatesResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetDevicePerformanceStatesCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::DevicePerformanceStateInfo, 20> states, int32_t status) {
+ if (_buffer.capacity() < GetDevicePerformanceStatesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetDevicePerformanceStatesResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetDevicePerformanceStatesResponse(
+ ::fidl::DecodedMessage<GetDevicePerformanceStatesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDevicePerformanceStatesResponse::PrimarySize,
+ GetDevicePerformanceStatesResponse::PrimarySize)));
+ _response.states = std::move(states);
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(GetDevicePerformanceStatesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDevicePerformanceStatesResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetDevicePerformanceStatesCompleterBase::Reply(::fidl::DecodedMessage<GetDevicePerformanceStatesResponse> params) {
+ Controller::SetTransactionHeaderFor::GetDevicePerformanceStatesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::UpdatePowerStateMappingCompleterBase::Reply(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdatePowerStateMappingResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UpdatePowerStateMappingResponse _response = {};
+ Controller::SetTransactionHeaderFor::UpdatePowerStateMappingResponse(
+ ::fidl::DecodedMessage<UpdatePowerStateMappingResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdatePowerStateMappingResponse::PrimarySize,
+ UpdatePowerStateMappingResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::UpdatePowerStateMappingCompleterBase::ReplySuccess() {
+ Controller_UpdatePowerStateMapping_Response response;
+
+ Reply(Controller_UpdatePowerStateMapping_Result::WithResponse(&response));
+}
+void Controller::Interface::UpdatePowerStateMappingCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_UpdatePowerStateMapping_Result::WithErr(&error));
+}
+
+void Controller::Interface::UpdatePowerStateMappingCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result result) {
+ if (_buffer.capacity() < UpdatePowerStateMappingResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UpdatePowerStateMappingResponse _response = {};
+ Controller::SetTransactionHeaderFor::UpdatePowerStateMappingResponse(
+ ::fidl::DecodedMessage<UpdatePowerStateMappingResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdatePowerStateMappingResponse::PrimarySize,
+ UpdatePowerStateMappingResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::UpdatePowerStateMappingCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_UpdatePowerStateMapping_Response response;
+
+ Reply(std::move(_buffer), Controller_UpdatePowerStateMapping_Result::WithResponse(&response));
+}
+
+void Controller::Interface::UpdatePowerStateMappingCompleterBase::Reply(::fidl::DecodedMessage<UpdatePowerStateMappingResponse> params) {
+ Controller::SetTransactionHeaderFor::UpdatePowerStateMappingResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetPowerStateMappingCompleterBase::Reply(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPowerStateMappingResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetPowerStateMappingResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetPowerStateMappingResponse(
+ ::fidl::DecodedMessage<GetPowerStateMappingResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPowerStateMappingResponse::PrimarySize,
+ GetPowerStateMappingResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::GetPowerStateMappingCompleterBase::ReplySuccess(::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping) {
+ Controller_GetPowerStateMapping_Response response;
+ response.mapping = std::move(mapping);
+
+ Reply(Controller_GetPowerStateMapping_Result::WithResponse(&response));
+}
+void Controller::Interface::GetPowerStateMappingCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_GetPowerStateMapping_Result::WithErr(&error));
+}
+
+void Controller::Interface::GetPowerStateMappingCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result result) {
+ if (_buffer.capacity() < GetPowerStateMappingResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPowerStateMappingResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetPowerStateMappingResponse(
+ ::fidl::DecodedMessage<GetPowerStateMappingResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPowerStateMappingResponse::PrimarySize,
+ GetPowerStateMappingResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::GetPowerStateMappingCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping) {
+ Controller_GetPowerStateMapping_Response response;
+ response.mapping = std::move(mapping);
+
+ Reply(std::move(_buffer), Controller_GetPowerStateMapping_Result::WithResponse(&response));
+}
+
+void Controller::Interface::GetPowerStateMappingCompleterBase::Reply(::fidl::DecodedMessage<GetPowerStateMappingResponse> params) {
+ Controller::SetTransactionHeaderFor::GetPowerStateMappingResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::SuspendCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::device::DevicePowerState out_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SuspendResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SuspendResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::SuspendResponse(
+ ::fidl::DecodedMessage<SuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendResponse::PrimarySize,
+ SuspendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.out_state = std::move(out_state);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SuspendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::SuspendCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::device::DevicePowerState out_state) {
+ if (_buffer.capacity() < SuspendResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SuspendResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::SuspendResponse(
+ ::fidl::DecodedMessage<SuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SuspendResponse::PrimarySize,
+ SuspendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.out_state = std::move(out_state);
+ _buffer.set_actual(sizeof(SuspendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SuspendResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::SuspendCompleterBase::Reply(::fidl::DecodedMessage<SuspendResponse> params) {
+ Controller::SetTransactionHeaderFor::SuspendResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::ResumeCompleterBase::Reply(::llcpp::fuchsia::device::Controller_Resume_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResumeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ResumeResponse _response = {};
+ Controller::SetTransactionHeaderFor::ResumeResponse(
+ ::fidl::DecodedMessage<ResumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResumeResponse::PrimarySize,
+ ResumeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ResumeCompleterBase::ReplySuccess(::llcpp::fuchsia::device::DevicePowerState out_state) {
+ Controller_Resume_Response response;
+ response.out_state = std::move(out_state);
+
+ Reply(Controller_Resume_Result::WithResponse(&response));
+}
+void Controller::Interface::ResumeCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_Resume_Result::WithErr(&error));
+}
+
+void Controller::Interface::ResumeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Resume_Result result) {
+ if (_buffer.capacity() < ResumeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ResumeResponse _response = {};
+ Controller::SetTransactionHeaderFor::ResumeResponse(
+ ::fidl::DecodedMessage<ResumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResumeResponse::PrimarySize,
+ ResumeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ResumeCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::DevicePowerState out_state) {
+ Controller_Resume_Response response;
+ response.out_state = std::move(out_state);
+
+ Reply(std::move(_buffer), Controller_Resume_Result::WithResponse(&response));
+}
+
+void Controller::Interface::ResumeCompleterBase::Reply(::fidl::DecodedMessage<ResumeResponse> params) {
+ Controller::SetTransactionHeaderFor::ResumeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::SetPerformanceStateCompleterBase::Reply(int32_t status, uint32_t out_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetPerformanceStateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetPerformanceStateResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::SetPerformanceStateResponse(
+ ::fidl::DecodedMessage<SetPerformanceStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetPerformanceStateResponse::PrimarySize,
+ SetPerformanceStateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.out_state = std::move(out_state);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetPerformanceStateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetPerformanceStateResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::SetPerformanceStateCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint32_t out_state) {
+ if (_buffer.capacity() < SetPerformanceStateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetPerformanceStateResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::SetPerformanceStateResponse(
+ ::fidl::DecodedMessage<SetPerformanceStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetPerformanceStateResponse::PrimarySize,
+ SetPerformanceStateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.out_state = std::move(out_state);
+ _buffer.set_actual(sizeof(SetPerformanceStateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetPerformanceStateResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::SetPerformanceStateCompleterBase::Reply(::fidl::DecodedMessage<SetPerformanceStateResponse> params) {
+ Controller::SetTransactionHeaderFor::SetPerformanceStateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::ConfigureAutoSuspendCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigureAutoSuspendResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConfigureAutoSuspendResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::ConfigureAutoSuspendResponse(
+ ::fidl::DecodedMessage<ConfigureAutoSuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigureAutoSuspendResponse::PrimarySize,
+ ConfigureAutoSuspendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigureAutoSuspendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigureAutoSuspendResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::ConfigureAutoSuspendCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ConfigureAutoSuspendResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConfigureAutoSuspendResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::ConfigureAutoSuspendResponse(
+ ::fidl::DecodedMessage<ConfigureAutoSuspendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigureAutoSuspendResponse::PrimarySize,
+ ConfigureAutoSuspendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ConfigureAutoSuspendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigureAutoSuspendResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::ConfigureAutoSuspendCompleterBase::Reply(::fidl::DecodedMessage<ConfigureAutoSuspendResponse> params) {
+ Controller::SetTransactionHeaderFor::ConfigureAutoSuspendResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Controller::SetTransactionHeaderFor::BindRequest(const ::fidl::DecodedMessage<Controller::BindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::BindResponse(const ::fidl::DecodedMessage<Controller::BindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::RebindRequest(const ::fidl::DecodedMessage<Controller::RebindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Rebind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::RebindResponse(const ::fidl::DecodedMessage<Controller::RebindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Rebind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ScheduleUnbindRequest(const ::fidl::DecodedMessage<Controller::ScheduleUnbindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ScheduleUnbind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ScheduleUnbindResponse(const ::fidl::DecodedMessage<Controller::ScheduleUnbindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ScheduleUnbind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetDriverNameRequest(const ::fidl::DecodedMessage<Controller::GetDriverNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDriverName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetDriverNameResponse(const ::fidl::DecodedMessage<Controller::GetDriverNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDriverName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetDeviceNameRequest(const ::fidl::DecodedMessage<Controller::GetDeviceNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDeviceName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetDeviceNameResponse(const ::fidl::DecodedMessage<Controller::GetDeviceNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDeviceName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetTopologicalPathRequest(const ::fidl::DecodedMessage<Controller::GetTopologicalPathRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetTopologicalPath_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetTopologicalPathResponse(const ::fidl::DecodedMessage<Controller::GetTopologicalPathResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetTopologicalPath_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetEventHandleRequest(const ::fidl::DecodedMessage<Controller::GetEventHandleRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetEventHandle_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetEventHandleResponse(const ::fidl::DecodedMessage<Controller::GetEventHandleResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetEventHandle_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetDriverLogFlagsRequest(const ::fidl::DecodedMessage<Controller::GetDriverLogFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDriverLogFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetDriverLogFlagsResponse(const ::fidl::DecodedMessage<Controller::GetDriverLogFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDriverLogFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetDriverLogFlagsRequest(const ::fidl::DecodedMessage<Controller::SetDriverLogFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetDriverLogFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::SetDriverLogFlagsResponse(const ::fidl::DecodedMessage<Controller::SetDriverLogFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetDriverLogFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::DebugResumeRequest(const ::fidl::DecodedMessage<Controller::DebugResumeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_DebugResume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::DebugResumeResponse(const ::fidl::DecodedMessage<Controller::DebugResumeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_DebugResume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::RunCompatibilityTestsRequest(const ::fidl::DecodedMessage<Controller::RunCompatibilityTestsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_RunCompatibilityTests_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::RunCompatibilityTestsResponse(const ::fidl::DecodedMessage<Controller::RunCompatibilityTestsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_RunCompatibilityTests_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetDevicePowerCapsRequest(const ::fidl::DecodedMessage<Controller::GetDevicePowerCapsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDevicePowerCaps_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetDevicePowerCapsResponse(const ::fidl::DecodedMessage<Controller::GetDevicePowerCapsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDevicePowerCaps_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetDevicePerformanceStatesRequest(const ::fidl::DecodedMessage<Controller::GetDevicePerformanceStatesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDevicePerformanceStates_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetDevicePerformanceStatesResponse(const ::fidl::DecodedMessage<Controller::GetDevicePerformanceStatesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetDevicePerformanceStates_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::UpdatePowerStateMappingRequest(const ::fidl::DecodedMessage<Controller::UpdatePowerStateMappingRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_UpdatePowerStateMapping_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::UpdatePowerStateMappingResponse(const ::fidl::DecodedMessage<Controller::UpdatePowerStateMappingResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_UpdatePowerStateMapping_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetPowerStateMappingRequest(const ::fidl::DecodedMessage<Controller::GetPowerStateMappingRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetPowerStateMapping_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetPowerStateMappingResponse(const ::fidl::DecodedMessage<Controller::GetPowerStateMappingResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetPowerStateMapping_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SuspendRequest(const ::fidl::DecodedMessage<Controller::SuspendRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Suspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::SuspendResponse(const ::fidl::DecodedMessage<Controller::SuspendResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Suspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ResumeRequest(const ::fidl::DecodedMessage<Controller::ResumeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Resume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ResumeResponse(const ::fidl::DecodedMessage<Controller::ResumeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Resume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetPerformanceStateRequest(const ::fidl::DecodedMessage<Controller::SetPerformanceStateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetPerformanceState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::SetPerformanceStateResponse(const ::fidl::DecodedMessage<Controller::SetPerformanceStateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetPerformanceState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ConfigureAutoSuspendRequest(const ::fidl::DecodedMessage<Controller::ConfigureAutoSuspendRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ConfigureAutoSuspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ConfigureAutoSuspendResponse(const ::fidl::DecodedMessage<Controller::ConfigureAutoSuspendResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ConfigureAutoSuspend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-device/gen/llcpp/include/fuchsia/device/llcpp/fidl.h b/zircon/system/fidl/fuchsia-device/gen/llcpp/include/fuchsia/device/llcpp/fidl.h
new file mode 100644
index 0000000..970b68e
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-device/gen/llcpp/include/fuchsia/device/llcpp/fidl.h
@@ -0,0 +1,3642 @@
+// 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/event.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/device/manager/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace device {
+
+struct NameProvider_GetDeviceName_Response;
+struct NameProvider_GetDeviceName_Result;
+class NameProvider;
+enum class DevicePowerState : uint8_t {
+ DEVICE_POWER_STATE_D0 = 0u,
+ DEVICE_POWER_STATE_D1 = 1u,
+ DEVICE_POWER_STATE_D2 = 2u,
+ DEVICE_POWER_STATE_D3HOT = 3u,
+ DEVICE_POWER_STATE_D3COLD = 4u,
+};
+
+
+struct SystemPowerStateInfo;
+struct Controller_GetPowerStateMapping_Response;
+struct Controller_GetPowerStateMapping_Result;
+struct DevicePowerStateInfo;
+struct Controller_GetDevicePowerCaps_Response;
+struct Controller_GetDevicePowerCaps_Result;
+struct Controller_Resume_Response;
+struct Controller_Resume_Result;
+struct DevicePerformanceStateInfo;
+struct Controller_UpdatePowerStateMapping_Response;
+struct Controller_UpdatePowerStateMapping_Result;
+struct Controller_ScheduleUnbind_Response;
+struct Controller_ScheduleUnbind_Result;
+struct Controller_Rebind_Response;
+struct Controller_Rebind_Result;
+struct Controller_GetTopologicalPath_Response;
+struct Controller_GetTopologicalPath_Result;
+struct Controller_Bind_Response;
+struct Controller_Bind_Result;
+class Controller;
+
+extern "C" const fidl_type_t v1_fuchsia_device_NameProvider_GetDeviceName_ResultTable;
+
+struct NameProvider_GetDeviceName_Result {
+ NameProvider_GetDeviceName_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static NameProvider_GetDeviceName_Result WithResponse(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response* val) {
+ NameProvider_GetDeviceName_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static NameProvider_GetDeviceName_Result WithErr(int32_t* val) {
+ NameProvider_GetDeviceName_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_NameProvider_GetDeviceName_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 272;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetPowerStateMapping_ResultTable;
+
+struct Controller_GetPowerStateMapping_Result {
+ Controller_GetPowerStateMapping_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_GetPowerStateMapping_Result WithResponse(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response* val) {
+ Controller_GetPowerStateMapping_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_GetPowerStateMapping_Result WithErr(int32_t* val) {
+ Controller_GetPowerStateMapping_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetPowerStateMapping_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 56;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetDevicePowerCaps_ResultTable;
+
+struct Controller_GetDevicePowerCaps_Result {
+ Controller_GetDevicePowerCaps_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_GetDevicePowerCaps_Result WithResponse(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response* val) {
+ Controller_GetDevicePowerCaps_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_GetDevicePowerCaps_Result WithErr(int32_t* val) {
+ Controller_GetDevicePowerCaps_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetDevicePowerCaps_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 120;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_Resume_ResultTable;
+
+struct Controller_Resume_Result {
+ Controller_Resume_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_Resume_Result WithResponse(::llcpp::fuchsia::device::Controller_Resume_Response* val) {
+ Controller_Resume_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::Controller_Resume_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::Controller_Resume_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_Resume_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::Controller_Resume_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_Resume_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_Resume_Result WithErr(int32_t* val) {
+ Controller_Resume_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Resume_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_UpdatePowerStateMapping_ResultTable;
+
+struct Controller_UpdatePowerStateMapping_Result {
+ Controller_UpdatePowerStateMapping_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_UpdatePowerStateMapping_Result WithResponse(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response* val) {
+ Controller_UpdatePowerStateMapping_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_UpdatePowerStateMapping_Result WithErr(int32_t* val) {
+ Controller_UpdatePowerStateMapping_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_UpdatePowerStateMapping_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_ScheduleUnbind_ResultTable;
+
+struct Controller_ScheduleUnbind_Result {
+ Controller_ScheduleUnbind_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_ScheduleUnbind_Result WithResponse(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response* val) {
+ Controller_ScheduleUnbind_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_ScheduleUnbind_Result WithErr(int32_t* val) {
+ Controller_ScheduleUnbind_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_ScheduleUnbind_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_Rebind_ResultTable;
+
+struct Controller_Rebind_Result {
+ Controller_Rebind_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_Rebind_Result WithResponse(::llcpp::fuchsia::device::Controller_Rebind_Response* val) {
+ Controller_Rebind_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::Controller_Rebind_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::Controller_Rebind_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_Rebind_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::Controller_Rebind_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_Rebind_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_Rebind_Result WithErr(int32_t* val) {
+ Controller_Rebind_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Rebind_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetTopologicalPath_ResultTable;
+
+struct Controller_GetTopologicalPath_Result {
+ Controller_GetTopologicalPath_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_GetTopologicalPath_Result WithResponse(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response* val) {
+ Controller_GetTopologicalPath_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_GetTopologicalPath_Result WithErr(int32_t* val) {
+ Controller_GetTopologicalPath_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetTopologicalPath_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 1040;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_Bind_ResultTable;
+
+struct Controller_Bind_Result {
+ Controller_Bind_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_Bind_Result WithResponse(::llcpp::fuchsia::device::Controller_Bind_Response* val) {
+ Controller_Bind_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::device::Controller_Bind_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::device::Controller_Bind_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_Bind_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::device::Controller_Bind_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::device::Controller_Bind_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_Bind_Result WithErr(int32_t* val) {
+ Controller_Bind_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Bind_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_NameProvider_GetDeviceName_ResponseTable;
+
+struct NameProvider_GetDeviceName_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_NameProvider_GetDeviceName_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 256;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::StringView name = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_NameProviderGetDeviceNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_NameProviderGetDeviceNameResponseTable;
+
+// Interface for getting device names.
+class NameProvider final {
+ NameProvider() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.device.NameProvider";
+
+ struct GetDeviceNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_NameProviderGetDeviceNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 272;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetDeviceNameRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetDeviceName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceName_Impl(::zx::unowned_channel _client_end);
+ ~GetDeviceName_Impl() = default;
+ GetDeviceName_Impl(GetDeviceName_Impl&& other) = default;
+ GetDeviceName_Impl& operator=(GetDeviceName_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 GetDeviceName = GetDeviceName_Impl<GetDeviceNameResponse>;
+ };
+
+ // 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 GetDeviceName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDeviceName_Impl() = default;
+ GetDeviceName_Impl(GetDeviceName_Impl&& other) = default;
+ GetDeviceName_Impl& operator=(GetDeviceName_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 GetDeviceName = GetDeviceName_Impl<GetDeviceNameResponse>;
+ };
+
+ 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_; }
+
+ // Return the name of this Fuchsia device.
+ // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDeviceName GetDeviceName();
+
+ // Return the name of this Fuchsia device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDeviceName GetDeviceName(::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:
+
+ // Return the name of this Fuchsia device.
+ // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDeviceName GetDeviceName(::zx::unowned_channel _client_end);
+
+ // Return the name of this Fuchsia device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDeviceName GetDeviceName(::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:
+
+ // Return the name of this Fuchsia device.
+ static ::fidl::DecodeResult<GetDeviceNameResponse> GetDeviceName(::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 = NameProvider;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetDeviceNameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result result);
+ void ReplySuccess(::fidl::StringView name);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView name);
+ void Reply(::fidl::DecodedMessage<GetDeviceNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDeviceNameCompleter = ::fidl::Completer<GetDeviceNameCompleterBase>;
+
+ virtual void GetDeviceName(GetDeviceNameCompleter::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 GetDeviceNameRequest(const ::fidl::DecodedMessage<NameProvider::GetDeviceNameRequest>& _msg);
+ static void GetDeviceNameResponse(const ::fidl::DecodedMessage<NameProvider::GetDeviceNameResponse>& _msg);
+ };
+};
+
+constexpr uint32_t MIN_DEVICE_POWER_STATES = 2u;
+
+constexpr uint32_t MIN_DEVICE_PERFORMANCE_STATES = 1u;
+
+// Maximum length for a driver path
+constexpr uint64_t MAX_DRIVER_PATH_LEN = 1024u;
+
+// Maxmium length for a driver name
+constexpr uint64_t MAX_DRIVER_NAME_LEN = 32u;
+
+// Maximum device power states. In future this should account
+// for performance states.
+constexpr uint32_t MAX_DEVICE_POWER_STATES = 5u;
+
+constexpr uint32_t MAX_DEVICE_PERFORMANCE_STATES = 20u;
+
+// Maximum length of a device path
+constexpr uint64_t MAX_DEVICE_PATH_LEN = 1024u;
+
+// Maxmium length for a device name
+constexpr uint64_t MAX_DEVICE_NAME_LEN = 32u;
+
+extern "C" const fidl_type_t v1_fuchsia_device_SystemPowerStateInfoTable;
+
+struct SystemPowerStateInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_SystemPowerStateInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t suspend_flag = {};
+
+ // Should wakeup be enabled from this system state?
+ bool wakeup_enable = {};
+
+ // Device power state that the device should be in for this system power state.
+ ::llcpp::fuchsia::device::DevicePowerState dev_state = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetPowerStateMapping_ResponseTable;
+
+struct Controller_GetPowerStateMapping_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetPowerStateMapping_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_DevicePowerStateInfoTable;
+
+struct DevicePowerStateInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_DevicePowerStateInfoTable;
+ 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;
+
+ ::llcpp::fuchsia::device::DevicePowerState state_id = {};
+
+ // Is this state supported?
+ bool is_supported = {};
+
+ // Restore time for coming out of this state to working D0 state.
+ int64_t restore_latency = {};
+
+ // Is this device wakeup_capable?
+ bool wakeup_capable = {};
+
+ // Deepest system system sleep state that the device can wake the system from.
+ int32_t system_wake_state = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetDevicePowerCaps_ResponseTable;
+
+struct Controller_GetDevicePowerCaps_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetDevicePowerCaps_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 120;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::fidl::Array<::llcpp::fuchsia::device::DevicePowerStateInfo, 5> dpstates = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_Resume_ResponseTable;
+
+struct Controller_Resume_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Resume_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::device::DevicePowerState out_state = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_DevicePerformanceStateInfoTable;
+
+// Performance state info for a device. A performance state is relevant only
+// when the device is in non-sleeping working device power state.
+struct DevicePerformanceStateInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_DevicePerformanceStateInfoTable;
+ 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;
+
+ int32_t state_id = {};
+
+ // Restore time for coming out of this state to fully working performance state.
+ int64_t restore_latency = {};
+
+ // Is this state supported?
+ bool is_supported = {};
+};
+
+// Signal that will be active on a device event handle if the device's write() method
+// will accept data.
+constexpr uint32_t DEVICE_SIGNAL_WRITABLE = 67108864u;
+
+// Signal that will be active on a device event handle if the device's read() method
+// will return data.
+constexpr uint32_t DEVICE_SIGNAL_READABLE = 16777216u;
+
+// Signal that will be active on a device event handle if the device has some out-of-band
+// mechanism that needs attention.
+// This is primarily used by the PTY support.
+constexpr uint32_t DEVICE_SIGNAL_OOB = 33554432u;
+
+// Signal that will be active on a device event handle if the device has been disconnected.
+// This is primarily used by the PTY support.
+constexpr uint32_t DEVICE_SIGNAL_HANGUP = 268435456u;
+
+// Signal that will be active on a device event handle if the device has encountered an error.
+// This is primarily used by the PTY support.
+constexpr uint32_t DEVICE_SIGNAL_ERROR = 134217728u;
+
+// [MANDATORY] Default performance state when the device is in DEVICE_POWER_STATE_D0
+constexpr uint32_t DEVICE_PERFORMANCE_STATE_P0 = 0u;
+
+// Maximum length of a device name (without a null byte), based on
+// HOST_NAME_MAX as defined by <limits.h>.
+constexpr uint32_t DEVICE_NAME_MAX = 255u;
+
+extern const char DEFAULT_DEVICE_NAME[];
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_UpdatePowerStateMapping_ResponseTable;
+
+struct Controller_UpdatePowerStateMapping_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_UpdatePowerStateMapping_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_ScheduleUnbind_ResponseTable;
+
+struct Controller_ScheduleUnbind_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_ScheduleUnbind_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_Rebind_ResponseTable;
+
+struct Controller_Rebind_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Rebind_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_GetTopologicalPath_ResponseTable;
+
+struct Controller_GetTopologicalPath_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_GetTopologicalPath_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::StringView path = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_Controller_Bind_ResponseTable;
+
+struct Controller_Bind_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_Controller_Bind_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerBindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerRebindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerRebindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerScheduleUnbindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerScheduleUnbindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDeviceNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDeviceNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetTopologicalPathRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetTopologicalPathResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetEventHandleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetEventHandleResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverLogFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDriverLogFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetDriverLogFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetDriverLogFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerDebugResumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerDebugResumeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerRunCompatibilityTestsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerRunCompatibilityTestsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePowerCapsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePowerCapsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePerformanceStatesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetDevicePerformanceStatesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerUpdatePowerStateMappingRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerUpdatePowerStateMappingResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetPowerStateMappingRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerGetPowerStateMappingResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSuspendResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerResumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerResumeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetPerformanceStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerSetPerformanceStateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerConfigureAutoSuspendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_device_ControllerConfigureAutoSuspendResponseTable;
+
+// Interface for manipulating a device in a devhost
+class Controller final {
+ Controller() = delete;
+ public:
+
+ struct BindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::Controller_Bind_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerBindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct BindRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView driver;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerBindRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = BindResponse;
+ };
+
+ struct RebindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::Controller_Rebind_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerRebindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RebindRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView driver;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerRebindRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = RebindResponse;
+ };
+
+ struct ScheduleUnbindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerScheduleUnbindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using ScheduleUnbindRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDriverNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::fidl::StringView name;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDriverNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ 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 GetDriverNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDeviceNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView name;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDeviceNameResponseTable;
+ 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 GetDeviceNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetTopologicalPathResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetTopologicalPathResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 1040;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetTopologicalPathRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetEventHandleResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::event event;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetEventHandleResponseTable;
+ 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 GetEventHandleRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDriverLogFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDriverLogFlagsResponseTable;
+ 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 GetDriverLogFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetDriverLogFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSetDriverLogFlagsResponseTable;
+ 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 SetDriverLogFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t clear_flags;
+ uint32_t set_flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSetDriverLogFlagsRequestTable;
+ 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 = SetDriverLogFlagsResponse;
+ };
+
+ struct DebugResumeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerDebugResumeResponseTable;
+ 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 DebugResumeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct RunCompatibilityTestsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerRunCompatibilityTestsResponseTable;
+ 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 RunCompatibilityTestsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int64_t hook_wait_time;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerRunCompatibilityTestsRequestTable;
+ 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 = RunCompatibilityTestsResponse;
+ };
+
+ struct GetDevicePowerCapsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDevicePowerCapsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 120;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetDevicePowerCapsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDevicePerformanceStatesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::Array<::llcpp::fuchsia::device::DevicePerformanceStateInfo, 20> states;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetDevicePerformanceStatesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 504;
+ 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 GetDevicePerformanceStatesRequest = ::fidl::AnyZeroArgMessage;
+
+ struct UpdatePowerStateMappingResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerUpdatePowerStateMappingResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UpdatePowerStateMappingRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerUpdatePowerStateMappingRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 72;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 72;
+ 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 = UpdatePowerStateMappingResponse;
+ };
+
+ struct GetPowerStateMappingResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerGetPowerStateMappingResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 56;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetPowerStateMappingRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SuspendResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::device::DevicePowerState out_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSuspendResponseTable;
+ 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 SuspendRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::DevicePowerState requested_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSuspendRequestTable;
+ 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 = SuspendResponse;
+ };
+
+ struct ResumeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::Controller_Resume_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerResumeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ResumeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::device::DevicePowerState requested_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerResumeRequestTable;
+ 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 = ResumeResponse;
+ };
+
+ struct SetPerformanceStateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint32_t out_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSetPerformanceStateResponseTable;
+ 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 SetPerformanceStateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t requested_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerSetPerformanceStateRequestTable;
+ 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 = SetPerformanceStateResponse;
+ };
+
+ struct ConfigureAutoSuspendResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerConfigureAutoSuspendResponseTable;
+ 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 ConfigureAutoSuspendRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool enable;
+ ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_device_ControllerConfigureAutoSuspendRequestTable;
+ 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 = ConfigureAutoSuspendResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Bind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Rebind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rebind_Impl(::zx::unowned_channel _client_end, ::fidl::StringView driver);
+ ~Rebind_Impl() = default;
+ Rebind_Impl(Rebind_Impl&& other) = default;
+ Rebind_Impl& operator=(Rebind_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 ScheduleUnbind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ScheduleUnbind_Impl(::zx::unowned_channel _client_end);
+ ~ScheduleUnbind_Impl() = default;
+ ScheduleUnbind_Impl(ScheduleUnbind_Impl&& other) = default;
+ ScheduleUnbind_Impl& operator=(ScheduleUnbind_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 GetDriverName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDriverName_Impl(::zx::unowned_channel _client_end);
+ ~GetDriverName_Impl() = default;
+ GetDriverName_Impl(GetDriverName_Impl&& other) = default;
+ GetDriverName_Impl& operator=(GetDriverName_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 GetDeviceName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceName_Impl(::zx::unowned_channel _client_end);
+ ~GetDeviceName_Impl() = default;
+ GetDeviceName_Impl(GetDeviceName_Impl&& other) = default;
+ GetDeviceName_Impl& operator=(GetDeviceName_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 GetTopologicalPath_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetTopologicalPath_Impl(::zx::unowned_channel _client_end);
+ ~GetTopologicalPath_Impl() = default;
+ GetTopologicalPath_Impl(GetTopologicalPath_Impl&& other) = default;
+ GetTopologicalPath_Impl& operator=(GetTopologicalPath_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 GetEventHandle_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetEventHandle_Impl(::zx::unowned_channel _client_end);
+ ~GetEventHandle_Impl() = default;
+ GetEventHandle_Impl(GetEventHandle_Impl&& other) = default;
+ GetEventHandle_Impl& operator=(GetEventHandle_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 GetDriverLogFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDriverLogFlags_Impl(::zx::unowned_channel _client_end);
+ ~GetDriverLogFlags_Impl() = default;
+ GetDriverLogFlags_Impl(GetDriverLogFlags_Impl&& other) = default;
+ GetDriverLogFlags_Impl& operator=(GetDriverLogFlags_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 SetDriverLogFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetDriverLogFlags_Impl(::zx::unowned_channel _client_end, uint32_t clear_flags, uint32_t set_flags);
+ ~SetDriverLogFlags_Impl() = default;
+ SetDriverLogFlags_Impl(SetDriverLogFlags_Impl&& other) = default;
+ SetDriverLogFlags_Impl& operator=(SetDriverLogFlags_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 DebugResume_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ DebugResume_Impl(::zx::unowned_channel _client_end);
+ ~DebugResume_Impl() = default;
+ DebugResume_Impl(DebugResume_Impl&& other) = default;
+ DebugResume_Impl& operator=(DebugResume_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 RunCompatibilityTests_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, int64_t hook_wait_time);
+ ~RunCompatibilityTests_Impl() = default;
+ RunCompatibilityTests_Impl(RunCompatibilityTests_Impl&& other) = default;
+ RunCompatibilityTests_Impl& operator=(RunCompatibilityTests_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 GetDevicePowerCaps_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDevicePowerCaps_Impl(::zx::unowned_channel _client_end);
+ ~GetDevicePowerCaps_Impl() = default;
+ GetDevicePowerCaps_Impl(GetDevicePowerCaps_Impl&& other) = default;
+ GetDevicePowerCaps_Impl& operator=(GetDevicePowerCaps_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 GetDevicePerformanceStates_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDevicePerformanceStates_Impl(::zx::unowned_channel _client_end);
+ ~GetDevicePerformanceStates_Impl() = default;
+ GetDevicePerformanceStates_Impl(GetDevicePerformanceStates_Impl&& other) = default;
+ GetDevicePerformanceStates_Impl& operator=(GetDevicePerformanceStates_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 UpdatePowerStateMapping_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UpdatePowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);
+ ~UpdatePowerStateMapping_Impl() = default;
+ UpdatePowerStateMapping_Impl(UpdatePowerStateMapping_Impl&& other) = default;
+ UpdatePowerStateMapping_Impl& operator=(UpdatePowerStateMapping_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 GetPowerStateMapping_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetPowerStateMapping_Impl(::zx::unowned_channel _client_end);
+ ~GetPowerStateMapping_Impl() = default;
+ GetPowerStateMapping_Impl(GetPowerStateMapping_Impl&& other) = default;
+ GetPowerStateMapping_Impl& operator=(GetPowerStateMapping_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 Suspend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Suspend_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state);
+ ~Suspend_Impl() = default;
+ Suspend_Impl(Suspend_Impl&& other) = default;
+ Suspend_Impl& operator=(Suspend_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 Resume_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Resume_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state);
+ ~Resume_Impl() = default;
+ Resume_Impl(Resume_Impl&& other) = default;
+ Resume_Impl& operator=(Resume_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 SetPerformanceState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetPerformanceState_Impl(::zx::unowned_channel _client_end, uint32_t requested_state);
+ ~SetPerformanceState_Impl() = default;
+ SetPerformanceState_Impl(SetPerformanceState_Impl&& other) = default;
+ SetPerformanceState_Impl& operator=(SetPerformanceState_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 ConfigureAutoSuspend_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ConfigureAutoSuspend_Impl(::zx::unowned_channel _client_end, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state);
+ ~ConfigureAutoSuspend_Impl() = default;
+ ConfigureAutoSuspend_Impl(ConfigureAutoSuspend_Impl&& other) = default;
+ ConfigureAutoSuspend_Impl& operator=(ConfigureAutoSuspend_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 Bind = Bind_Impl<BindResponse>;
+ using Rebind = Rebind_Impl<RebindResponse>;
+ using ScheduleUnbind = ScheduleUnbind_Impl<ScheduleUnbindResponse>;
+ using GetDriverName = GetDriverName_Impl<GetDriverNameResponse>;
+ using GetDeviceName = GetDeviceName_Impl<GetDeviceNameResponse>;
+ using GetTopologicalPath = GetTopologicalPath_Impl<GetTopologicalPathResponse>;
+ using GetEventHandle = GetEventHandle_Impl<GetEventHandleResponse>;
+ using GetDriverLogFlags = GetDriverLogFlags_Impl<GetDriverLogFlagsResponse>;
+ using SetDriverLogFlags = SetDriverLogFlags_Impl<SetDriverLogFlagsResponse>;
+ using DebugResume = DebugResume_Impl<DebugResumeResponse>;
+ using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
+ using GetDevicePowerCaps = GetDevicePowerCaps_Impl<GetDevicePowerCapsResponse>;
+ using GetDevicePerformanceStates = GetDevicePerformanceStates_Impl<GetDevicePerformanceStatesResponse>;
+ using UpdatePowerStateMapping = UpdatePowerStateMapping_Impl<UpdatePowerStateMappingResponse>;
+ using GetPowerStateMapping = GetPowerStateMapping_Impl<GetPowerStateMappingResponse>;
+ using Suspend = Suspend_Impl<SuspendResponse>;
+ using Resume = Resume_Impl<ResumeResponse>;
+ using SetPerformanceState = SetPerformanceState_Impl<SetPerformanceStateResponse>;
+ using ConfigureAutoSuspend = ConfigureAutoSuspend_Impl<ConfigureAutoSuspendResponse>;
+ };
+
+ // 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 Bind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Rebind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rebind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);
+ ~Rebind_Impl() = default;
+ Rebind_Impl(Rebind_Impl&& other) = default;
+ Rebind_Impl& operator=(Rebind_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 ScheduleUnbind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ScheduleUnbind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ScheduleUnbind_Impl() = default;
+ ScheduleUnbind_Impl(ScheduleUnbind_Impl&& other) = default;
+ ScheduleUnbind_Impl& operator=(ScheduleUnbind_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 GetDriverName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDriverName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDriverName_Impl() = default;
+ GetDriverName_Impl(GetDriverName_Impl&& other) = default;
+ GetDriverName_Impl& operator=(GetDriverName_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 GetDeviceName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDeviceName_Impl() = default;
+ GetDeviceName_Impl(GetDeviceName_Impl&& other) = default;
+ GetDeviceName_Impl& operator=(GetDeviceName_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 GetTopologicalPath_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetTopologicalPath_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetTopologicalPath_Impl() = default;
+ GetTopologicalPath_Impl(GetTopologicalPath_Impl&& other) = default;
+ GetTopologicalPath_Impl& operator=(GetTopologicalPath_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 GetEventHandle_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetEventHandle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetEventHandle_Impl() = default;
+ GetEventHandle_Impl(GetEventHandle_Impl&& other) = default;
+ GetEventHandle_Impl& operator=(GetEventHandle_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 GetDriverLogFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDriverLogFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDriverLogFlags_Impl() = default;
+ GetDriverLogFlags_Impl(GetDriverLogFlags_Impl&& other) = default;
+ GetDriverLogFlags_Impl& operator=(GetDriverLogFlags_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 SetDriverLogFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetDriverLogFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer);
+ ~SetDriverLogFlags_Impl() = default;
+ SetDriverLogFlags_Impl(SetDriverLogFlags_Impl&& other) = default;
+ SetDriverLogFlags_Impl& operator=(SetDriverLogFlags_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 DebugResume_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ DebugResume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~DebugResume_Impl() = default;
+ DebugResume_Impl(DebugResume_Impl&& other) = default;
+ DebugResume_Impl& operator=(DebugResume_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 RunCompatibilityTests_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RunCompatibilityTests_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer);
+ ~RunCompatibilityTests_Impl() = default;
+ RunCompatibilityTests_Impl(RunCompatibilityTests_Impl&& other) = default;
+ RunCompatibilityTests_Impl& operator=(RunCompatibilityTests_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 GetDevicePowerCaps_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDevicePowerCaps_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDevicePowerCaps_Impl() = default;
+ GetDevicePowerCaps_Impl(GetDevicePowerCaps_Impl&& other) = default;
+ GetDevicePowerCaps_Impl& operator=(GetDevicePowerCaps_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 GetDevicePerformanceStates_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDevicePerformanceStates_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDevicePerformanceStates_Impl() = default;
+ GetDevicePerformanceStates_Impl(GetDevicePerformanceStates_Impl&& other) = default;
+ GetDevicePerformanceStates_Impl& operator=(GetDevicePerformanceStates_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 UpdatePowerStateMapping_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UpdatePowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer);
+ ~UpdatePowerStateMapping_Impl() = default;
+ UpdatePowerStateMapping_Impl(UpdatePowerStateMapping_Impl&& other) = default;
+ UpdatePowerStateMapping_Impl& operator=(UpdatePowerStateMapping_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 GetPowerStateMapping_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetPowerStateMapping_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetPowerStateMapping_Impl() = default;
+ GetPowerStateMapping_Impl(GetPowerStateMapping_Impl&& other) = default;
+ GetPowerStateMapping_Impl& operator=(GetPowerStateMapping_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 Suspend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Suspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
+ ~Suspend_Impl() = default;
+ Suspend_Impl(Suspend_Impl&& other) = default;
+ Suspend_Impl& operator=(Suspend_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 Resume_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Resume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
+ ~Resume_Impl() = default;
+ Resume_Impl(Resume_Impl&& other) = default;
+ Resume_Impl& operator=(Resume_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 SetPerformanceState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetPerformanceState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer);
+ ~SetPerformanceState_Impl() = default;
+ SetPerformanceState_Impl(SetPerformanceState_Impl&& other) = default;
+ SetPerformanceState_Impl& operator=(SetPerformanceState_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 ConfigureAutoSuspend_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ConfigureAutoSuspend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::fidl::BytePart _response_buffer);
+ ~ConfigureAutoSuspend_Impl() = default;
+ ConfigureAutoSuspend_Impl(ConfigureAutoSuspend_Impl&& other) = default;
+ ConfigureAutoSuspend_Impl& operator=(ConfigureAutoSuspend_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 Bind = Bind_Impl<BindResponse>;
+ using Rebind = Rebind_Impl<RebindResponse>;
+ using ScheduleUnbind = ScheduleUnbind_Impl<ScheduleUnbindResponse>;
+ using GetDriverName = GetDriverName_Impl<GetDriverNameResponse>;
+ using GetDeviceName = GetDeviceName_Impl<GetDeviceNameResponse>;
+ using GetTopologicalPath = GetTopologicalPath_Impl<GetTopologicalPathResponse>;
+ using GetEventHandle = GetEventHandle_Impl<GetEventHandleResponse>;
+ using GetDriverLogFlags = GetDriverLogFlags_Impl<GetDriverLogFlagsResponse>;
+ using SetDriverLogFlags = SetDriverLogFlags_Impl<SetDriverLogFlagsResponse>;
+ using DebugResume = DebugResume_Impl<DebugResumeResponse>;
+ using RunCompatibilityTests = RunCompatibilityTests_Impl<RunCompatibilityTestsResponse>;
+ using GetDevicePowerCaps = GetDevicePowerCaps_Impl<GetDevicePowerCapsResponse>;
+ using GetDevicePerformanceStates = GetDevicePerformanceStates_Impl<GetDevicePerformanceStatesResponse>;
+ using UpdatePowerStateMapping = UpdatePowerStateMapping_Impl<UpdatePowerStateMappingResponse>;
+ using GetPowerStateMapping = GetPowerStateMapping_Impl<GetPowerStateMappingResponse>;
+ using Suspend = Suspend_Impl<SuspendResponse>;
+ using Resume = Resume_Impl<ResumeResponse>;
+ using SetPerformanceState = SetPerformanceState_Impl<SetPerformanceStateResponse>;
+ using ConfigureAutoSuspend = ConfigureAutoSuspend_Impl<ConfigureAutoSuspendResponse>;
+ };
+
+ 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_; }
+
+ // Attempt to bind the requested driver to this device
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Bind Bind(::fidl::StringView driver);
+
+ // Attempt to bind the requested driver to this device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Bind Bind(::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);
+
+ // This api will unbind all the children of this device and bind the
+ // requested driver. If the driver is empty, it will autobind.
+ // The Rebind will not return until the bind completes.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Rebind Rebind(::fidl::StringView driver);
+
+ // This api will unbind all the children of this device and bind the
+ // requested driver. If the driver is empty, it will autobind.
+ // The Rebind will not return until the bind completes.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rebind Rebind(::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);
+
+ // Disconnect this device and allow its parent to be bound again.
+ // This may not complete before it returns.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ScheduleUnbind ScheduleUnbind();
+
+ // Disconnect this device and allow its parent to be bound again.
+ // This may not complete before it returns.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ScheduleUnbind ScheduleUnbind(::fidl::BytePart _response_buffer);
+
+ // Return the name of the driver managing this the device
+ // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDriverName GetDriverName();
+
+ // Return the name of the driver managing this the device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDriverName GetDriverName(::fidl::BytePart _response_buffer);
+
+ // Return the name of the device
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDeviceName GetDeviceName();
+
+ // Return the name of the device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDeviceName GetDeviceName(::fidl::BytePart _response_buffer);
+
+ // Return the topological path for this device
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetTopologicalPath GetTopologicalPath();
+
+ // Return the topological path for this device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetTopologicalPath GetTopologicalPath(::fidl::BytePart _response_buffer);
+
+ // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetEventHandle GetEventHandle();
+
+ // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetEventHandle GetEventHandle(::fidl::BytePart _response_buffer);
+
+ // Return the current logging flags for this device's driver
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDriverLogFlags GetDriverLogFlags();
+
+ // Return the current logging flags for this device's driver
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDriverLogFlags GetDriverLogFlags(::fidl::BytePart _response_buffer);
+
+ // Set the logging flags for this device's driver.
+ // Each set bit in `clear_flags` will be cleared in the log flags state.
+ // Each set bit in `set_flags` will then be set in the log flags state.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetDriverLogFlags SetDriverLogFlags(uint32_t clear_flags, uint32_t set_flags);
+
+ // Set the logging flags for this device's driver.
+ // Each set bit in `clear_flags` will be cleared in the log flags state.
+ // Each set bit in `set_flags` will then be set in the log flags state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetDriverLogFlags SetDriverLogFlags(::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer);
+
+ // Debug command: execute the device's resume hook
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DebugResume DebugResume();
+
+ // Debug command: execute the device's resume hook
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DebugResume DebugResume(::fidl::BytePart _response_buffer);
+
+ // Runs compatibility tests for the driver that binds to this device.
+ // The |hook_wait_time| is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the driver passed the compatibility check.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RunCompatibilityTests RunCompatibilityTests(int64_t hook_wait_time);
+
+ // Runs compatibility tests for the driver that binds to this device.
+ // The |hook_wait_time| is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the driver passed the compatibility check.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RunCompatibilityTests RunCompatibilityTests(::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer);
+
+ // Gets the device power capabilities. Used by the system wide power manager
+ // to manage power for this device.
+ // Allocates 176 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDevicePowerCaps GetDevicePowerCaps();
+
+ // Gets the device power capabilities. Used by the system wide power manager
+ // to manage power for this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDevicePowerCaps GetDevicePowerCaps(::fidl::BytePart _response_buffer);
+
+ // Gets the device performance states. Used by the system wide power manager
+ // to manage power for this device.
+ // Allocates 520 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDevicePerformanceStates GetDevicePerformanceStates();
+
+ // Gets the device performance states. Used by the system wide power manager
+ // to manage power for this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDevicePerformanceStates GetDevicePerformanceStates(::fidl::BytePart _response_buffer);
+
+ // Updates the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device
+ // Allocates 120 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);
+
+ // Updates the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer);
+
+ // Get the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetPowerStateMapping GetPowerStateMapping();
+
+ // Get the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetPowerStateMapping GetPowerStateMapping(::fidl::BytePart _response_buffer);
+
+ // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
+ // state.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Suspend Suspend(::llcpp::fuchsia::device::DevicePowerState requested_state);
+
+ // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
+ // state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Suspend Suspend(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
+
+ // Transition this device from a sleep state to a working state.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Resume Resume(::llcpp::fuchsia::device::DevicePowerState requested_state);
+
+ // Transition this device from a sleep state to a working state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Resume Resume(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
+
+ // Set the performance state of this device to the requested performance state. This is only
+ // called for the current device and none of the descendants are aware of the state
+ // transition.
+ // On success, the out_state and the requested_state is same. If the device is in a working
+ // state, the performance state will be changed to requested_state immediately. If the device
+ // is in non-working state, the performance state will be the requested_state whenever the
+ // device transitions to working state.
+ // On failure, the out_state will have the state that the device can go into.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetPerformanceState SetPerformanceState(uint32_t requested_state);
+
+ // Set the performance state of this device to the requested performance state. This is only
+ // called for the current device and none of the descendants are aware of the state
+ // transition.
+ // On success, the out_state and the requested_state is same. If the device is in a working
+ // state, the performance state will be changed to requested_state immediately. If the device
+ // is in non-working state, the performance state will be the requested_state whenever the
+ // device transitions to working state.
+ // On failure, the out_state will have the state that the device can go into.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetPerformanceState SetPerformanceState(::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer);
+
+ // Configure autosuspend of device to this deepest sleep state.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConfigureAutoSuspend ConfigureAutoSuspend(bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state);
+
+ // Configure autosuspend of device to this deepest sleep state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConfigureAutoSuspend ConfigureAutoSuspend(::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::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:
+
+ // Attempt to bind the requested driver to this device
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::StringView driver);
+
+ // Attempt to bind the requested driver to this device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);
+
+ // This api will unbind all the children of this device and bind the
+ // requested driver. If the driver is empty, it will autobind.
+ // The Rebind will not return until the bind completes.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Rebind Rebind(::zx::unowned_channel _client_end, ::fidl::StringView driver);
+
+ // This api will unbind all the children of this device and bind the
+ // requested driver. If the driver is empty, it will autobind.
+ // The Rebind will not return until the bind completes.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rebind Rebind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView driver, ::fidl::BytePart _response_buffer);
+
+ // Disconnect this device and allow its parent to be bound again.
+ // This may not complete before it returns.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ScheduleUnbind ScheduleUnbind(::zx::unowned_channel _client_end);
+
+ // Disconnect this device and allow its parent to be bound again.
+ // This may not complete before it returns.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ScheduleUnbind ScheduleUnbind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Return the name of the driver managing this the device
+ // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDriverName GetDriverName(::zx::unowned_channel _client_end);
+
+ // Return the name of the driver managing this the device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDriverName GetDriverName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Return the name of the device
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDeviceName GetDeviceName(::zx::unowned_channel _client_end);
+
+ // Return the name of the device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDeviceName GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Return the topological path for this device
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetTopologicalPath GetTopologicalPath(::zx::unowned_channel _client_end);
+
+ // Return the topological path for this device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetTopologicalPath GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetEventHandle GetEventHandle(::zx::unowned_channel _client_end);
+
+ // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetEventHandle GetEventHandle(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Return the current logging flags for this device's driver
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDriverLogFlags GetDriverLogFlags(::zx::unowned_channel _client_end);
+
+ // Return the current logging flags for this device's driver
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDriverLogFlags GetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Set the logging flags for this device's driver.
+ // Each set bit in `clear_flags` will be cleared in the log flags state.
+ // Each set bit in `set_flags` will then be set in the log flags state.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetDriverLogFlags SetDriverLogFlags(::zx::unowned_channel _client_end, uint32_t clear_flags, uint32_t set_flags);
+
+ // Set the logging flags for this device's driver.
+ // Each set bit in `clear_flags` will be cleared in the log flags state.
+ // Each set bit in `set_flags` will then be set in the log flags state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetDriverLogFlags SetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clear_flags, uint32_t set_flags, ::fidl::BytePart _response_buffer);
+
+ // Debug command: execute the device's resume hook
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DebugResume DebugResume(::zx::unowned_channel _client_end);
+
+ // Debug command: execute the device's resume hook
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DebugResume DebugResume(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Runs compatibility tests for the driver that binds to this device.
+ // The |hook_wait_time| is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the driver passed the compatibility check.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RunCompatibilityTests RunCompatibilityTests(::zx::unowned_channel _client_end, int64_t hook_wait_time);
+
+ // Runs compatibility tests for the driver that binds to this device.
+ // The |hook_wait_time| is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the driver passed the compatibility check.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RunCompatibilityTests RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t hook_wait_time, ::fidl::BytePart _response_buffer);
+
+ // Gets the device power capabilities. Used by the system wide power manager
+ // to manage power for this device.
+ // Allocates 176 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDevicePowerCaps GetDevicePowerCaps(::zx::unowned_channel _client_end);
+
+ // Gets the device power capabilities. Used by the system wide power manager
+ // to manage power for this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDevicePowerCaps GetDevicePowerCaps(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Gets the device performance states. Used by the system wide power manager
+ // to manage power for this device.
+ // Allocates 520 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDevicePerformanceStates GetDevicePerformanceStates(::zx::unowned_channel _client_end);
+
+ // Gets the device performance states. Used by the system wide power manager
+ // to manage power for this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDevicePerformanceStates GetDevicePerformanceStates(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device
+ // Allocates 120 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);
+
+ // Updates the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UpdatePowerStateMapping UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, ::fidl::BytePart _response_buffer);
+
+ // Get the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetPowerStateMapping GetPowerStateMapping(::zx::unowned_channel _client_end);
+
+ // Get the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetPowerStateMapping GetPowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
+ // state.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Suspend Suspend(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state);
+
+ // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
+ // state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Suspend Suspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
+
+ // Transition this device from a sleep state to a working state.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Resume Resume(::zx::unowned_channel _client_end, ::llcpp::fuchsia::device::DevicePowerState requested_state);
+
+ // Transition this device from a sleep state to a working state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Resume Resume(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::device::DevicePowerState requested_state, ::fidl::BytePart _response_buffer);
+
+ // Set the performance state of this device to the requested performance state. This is only
+ // called for the current device and none of the descendants are aware of the state
+ // transition.
+ // On success, the out_state and the requested_state is same. If the device is in a working
+ // state, the performance state will be changed to requested_state immediately. If the device
+ // is in non-working state, the performance state will be the requested_state whenever the
+ // device transitions to working state.
+ // On failure, the out_state will have the state that the device can go into.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetPerformanceState SetPerformanceState(::zx::unowned_channel _client_end, uint32_t requested_state);
+
+ // Set the performance state of this device to the requested performance state. This is only
+ // called for the current device and none of the descendants are aware of the state
+ // transition.
+ // On success, the out_state and the requested_state is same. If the device is in a working
+ // state, the performance state will be changed to requested_state immediately. If the device
+ // is in non-working state, the performance state will be the requested_state whenever the
+ // device transitions to working state.
+ // On failure, the out_state will have the state that the device can go into.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetPerformanceState SetPerformanceState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t requested_state, ::fidl::BytePart _response_buffer);
+
+ // Configure autosuspend of device to this deepest sleep state.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConfigureAutoSuspend ConfigureAutoSuspend(::zx::unowned_channel _client_end, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state);
+
+ // Configure autosuspend of device to this deepest sleep state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConfigureAutoSuspend ConfigureAutoSuspend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ::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:
+
+ // Attempt to bind the requested driver to this device
+ static ::fidl::DecodeResult<BindResponse> Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer);
+
+ // This api will unbind all the children of this device and bind the
+ // requested driver. If the driver is empty, it will autobind.
+ // The Rebind will not return until the bind completes.
+ static ::fidl::DecodeResult<RebindResponse> Rebind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RebindRequest> params, ::fidl::BytePart response_buffer);
+
+ // Disconnect this device and allow its parent to be bound again.
+ // This may not complete before it returns.
+ static ::fidl::DecodeResult<ScheduleUnbindResponse> ScheduleUnbind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return the name of the driver managing this the device
+ static ::fidl::DecodeResult<GetDriverNameResponse> GetDriverName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return the name of the device
+ static ::fidl::DecodeResult<GetDeviceNameResponse> GetDeviceName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return the topological path for this device
+ static ::fidl::DecodeResult<GetTopologicalPathResponse> GetTopologicalPath(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get an event for monitoring device conditions (see `DEVICE_SIGNAL_*` constants)
+ static ::fidl::DecodeResult<GetEventHandleResponse> GetEventHandle(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return the current logging flags for this device's driver
+ static ::fidl::DecodeResult<GetDriverLogFlagsResponse> GetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Set the logging flags for this device's driver.
+ // Each set bit in `clear_flags` will be cleared in the log flags state.
+ // Each set bit in `set_flags` will then be set in the log flags state.
+ static ::fidl::DecodeResult<SetDriverLogFlagsResponse> SetDriverLogFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDriverLogFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Debug command: execute the device's resume hook
+ static ::fidl::DecodeResult<DebugResumeResponse> DebugResume(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Runs compatibility tests for the driver that binds to this device.
+ // The |hook_wait_time| is the time that the driver expects to take for
+ // each device hook in nanoseconds.
+ // Returns whether the driver passed the compatibility check.
+ static ::fidl::DecodeResult<RunCompatibilityTestsResponse> RunCompatibilityTests(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RunCompatibilityTestsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Gets the device power capabilities. Used by the system wide power manager
+ // to manage power for this device.
+ static ::fidl::DecodeResult<GetDevicePowerCapsResponse> GetDevicePowerCaps(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Gets the device performance states. Used by the system wide power manager
+ // to manage power for this device.
+ static ::fidl::DecodeResult<GetDevicePerformanceStatesResponse> GetDevicePerformanceStates(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device
+ static ::fidl::DecodeResult<UpdatePowerStateMappingResponse> UpdatePowerStateMapping(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdatePowerStateMappingRequest> params, ::fidl::BytePart response_buffer);
+
+ // Get the mapping between system power states to device power states. Used by the system
+ // wide power manager to manage power for this device.
+ static ::fidl::DecodeResult<GetPowerStateMappingResponse> GetPowerStateMapping(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Transition this device from a working to a sleep state or from a sleep state to a deeper sleep
+ // state.
+ static ::fidl::DecodeResult<SuspendResponse> Suspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SuspendRequest> params, ::fidl::BytePart response_buffer);
+
+ // Transition this device from a sleep state to a working state.
+ static ::fidl::DecodeResult<ResumeResponse> Resume(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResumeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Set the performance state of this device to the requested performance state. This is only
+ // called for the current device and none of the descendants are aware of the state
+ // transition.
+ // On success, the out_state and the requested_state is same. If the device is in a working
+ // state, the performance state will be changed to requested_state immediately. If the device
+ // is in non-working state, the performance state will be the requested_state whenever the
+ // device transitions to working state.
+ // On failure, the out_state will have the state that the device can go into.
+ static ::fidl::DecodeResult<SetPerformanceStateResponse> SetPerformanceState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPerformanceStateRequest> params, ::fidl::BytePart response_buffer);
+
+ // Configure autosuspend of device to this deepest sleep state.
+ static ::fidl::DecodeResult<ConfigureAutoSuspendResponse> ConfigureAutoSuspend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigureAutoSuspendRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Controller;
+ using _Base = ::fidl::CompleterBase;
+
+ class BindCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::Controller_Bind_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Bind_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<BindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BindCompleter = ::fidl::Completer<BindCompleterBase>;
+
+ virtual void Bind(::fidl::StringView driver, BindCompleter::Sync _completer) = 0;
+
+ class RebindCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::Controller_Rebind_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Rebind_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<RebindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RebindCompleter = ::fidl::Completer<RebindCompleterBase>;
+
+ virtual void Rebind(::fidl::StringView driver, RebindCompleter::Sync _completer) = 0;
+
+ class ScheduleUnbindCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ScheduleUnbindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ScheduleUnbindCompleter = ::fidl::Completer<ScheduleUnbindCompleterBase>;
+
+ virtual void ScheduleUnbind(ScheduleUnbindCompleter::Sync _completer) = 0;
+
+ class GetDriverNameCompleterBase : 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<GetDriverNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDriverNameCompleter = ::fidl::Completer<GetDriverNameCompleterBase>;
+
+ virtual void GetDriverName(GetDriverNameCompleter::Sync _completer) = 0;
+
+ class GetDeviceNameCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::StringView name);
+ void Reply(::fidl::BytePart _buffer, ::fidl::StringView name);
+ void Reply(::fidl::DecodedMessage<GetDeviceNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDeviceNameCompleter = ::fidl::Completer<GetDeviceNameCompleterBase>;
+
+ virtual void GetDeviceName(GetDeviceNameCompleter::Sync _completer) = 0;
+
+ class GetTopologicalPathCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result result);
+ void ReplySuccess(::fidl::StringView path);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView path);
+ void Reply(::fidl::DecodedMessage<GetTopologicalPathResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTopologicalPathCompleter = ::fidl::Completer<GetTopologicalPathCompleterBase>;
+
+ virtual void GetTopologicalPath(GetTopologicalPathCompleter::Sync _completer) = 0;
+
+ class GetEventHandleCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::event event);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event event);
+ void Reply(::fidl::DecodedMessage<GetEventHandleResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetEventHandleCompleter = ::fidl::Completer<GetEventHandleCompleterBase>;
+
+ virtual void GetEventHandle(GetEventHandleCompleter::Sync _completer) = 0;
+
+ class GetDriverLogFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<GetDriverLogFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDriverLogFlagsCompleter = ::fidl::Completer<GetDriverLogFlagsCompleterBase>;
+
+ virtual void GetDriverLogFlags(GetDriverLogFlagsCompleter::Sync _completer) = 0;
+
+ class SetDriverLogFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetDriverLogFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetDriverLogFlagsCompleter = ::fidl::Completer<SetDriverLogFlagsCompleterBase>;
+
+ virtual void SetDriverLogFlags(uint32_t clear_flags, uint32_t set_flags, SetDriverLogFlagsCompleter::Sync _completer) = 0;
+
+ class DebugResumeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<DebugResumeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DebugResumeCompleter = ::fidl::Completer<DebugResumeCompleterBase>;
+
+ virtual void DebugResume(DebugResumeCompleter::Sync _completer) = 0;
+
+ class RunCompatibilityTestsCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t status);
+ void Reply(::fidl::BytePart _buffer, uint32_t status);
+ void Reply(::fidl::DecodedMessage<RunCompatibilityTestsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RunCompatibilityTestsCompleter = ::fidl::Completer<RunCompatibilityTestsCompleterBase>;
+
+ virtual void RunCompatibilityTests(int64_t hook_wait_time, RunCompatibilityTestsCompleter::Sync _completer) = 0;
+
+ class GetDevicePowerCapsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result result);
+ void ReplySuccess(::fidl::Array<::llcpp::fuchsia::device::DevicePowerStateInfo, 5> dpstates);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::DevicePowerStateInfo, 5> dpstates);
+ void Reply(::fidl::DecodedMessage<GetDevicePowerCapsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDevicePowerCapsCompleter = ::fidl::Completer<GetDevicePowerCapsCompleterBase>;
+
+ virtual void GetDevicePowerCaps(GetDevicePowerCapsCompleter::Sync _completer) = 0;
+
+ class GetDevicePerformanceStatesCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::Array<::llcpp::fuchsia::device::DevicePerformanceStateInfo, 20> states, int32_t status);
+ void Reply(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::DevicePerformanceStateInfo, 20> states, int32_t status);
+ void Reply(::fidl::DecodedMessage<GetDevicePerformanceStatesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDevicePerformanceStatesCompleter = ::fidl::Completer<GetDevicePerformanceStatesCompleterBase>;
+
+ virtual void GetDevicePerformanceStates(GetDevicePerformanceStatesCompleter::Sync _completer) = 0;
+
+ class UpdatePowerStateMappingCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UpdatePowerStateMappingResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UpdatePowerStateMappingCompleter = ::fidl::Completer<UpdatePowerStateMappingCompleterBase>;
+
+ virtual void UpdatePowerStateMapping(::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping, UpdatePowerStateMappingCompleter::Sync _completer) = 0;
+
+ class GetPowerStateMappingCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result result);
+ void ReplySuccess(::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::Array<::llcpp::fuchsia::device::SystemPowerStateInfo, 7> mapping);
+ void Reply(::fidl::DecodedMessage<GetPowerStateMappingResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPowerStateMappingCompleter = ::fidl::Completer<GetPowerStateMappingCompleterBase>;
+
+ virtual void GetPowerStateMapping(GetPowerStateMappingCompleter::Sync _completer) = 0;
+
+ class SuspendCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::device::DevicePowerState out_state);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::device::DevicePowerState out_state);
+ void Reply(::fidl::DecodedMessage<SuspendResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SuspendCompleter = ::fidl::Completer<SuspendCompleterBase>;
+
+ virtual void Suspend(::llcpp::fuchsia::device::DevicePowerState requested_state, SuspendCompleter::Sync _completer) = 0;
+
+ class ResumeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::device::Controller_Resume_Result result);
+ void ReplySuccess(::llcpp::fuchsia::device::DevicePowerState out_state);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::Controller_Resume_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::device::DevicePowerState out_state);
+ void Reply(::fidl::DecodedMessage<ResumeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ResumeCompleter = ::fidl::Completer<ResumeCompleterBase>;
+
+ virtual void Resume(::llcpp::fuchsia::device::DevicePowerState requested_state, ResumeCompleter::Sync _completer) = 0;
+
+ class SetPerformanceStateCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint32_t out_state);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint32_t out_state);
+ void Reply(::fidl::DecodedMessage<SetPerformanceStateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetPerformanceStateCompleter = ::fidl::Completer<SetPerformanceStateCompleterBase>;
+
+ virtual void SetPerformanceState(uint32_t requested_state, SetPerformanceStateCompleter::Sync _completer) = 0;
+
+ class ConfigureAutoSuspendCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ConfigureAutoSuspendResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConfigureAutoSuspendCompleter = ::fidl::Completer<ConfigureAutoSuspendCompleterBase>;
+
+ virtual void ConfigureAutoSuspend(bool enable, ::llcpp::fuchsia::device::DevicePowerState requested_deepest_sleep_state, ConfigureAutoSuspendCompleter::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 BindRequest(const ::fidl::DecodedMessage<Controller::BindRequest>& _msg);
+ static void BindResponse(const ::fidl::DecodedMessage<Controller::BindResponse>& _msg);
+ static void RebindRequest(const ::fidl::DecodedMessage<Controller::RebindRequest>& _msg);
+ static void RebindResponse(const ::fidl::DecodedMessage<Controller::RebindResponse>& _msg);
+ static void ScheduleUnbindRequest(const ::fidl::DecodedMessage<Controller::ScheduleUnbindRequest>& _msg);
+ static void ScheduleUnbindResponse(const ::fidl::DecodedMessage<Controller::ScheduleUnbindResponse>& _msg);
+ static void GetDriverNameRequest(const ::fidl::DecodedMessage<Controller::GetDriverNameRequest>& _msg);
+ static void GetDriverNameResponse(const ::fidl::DecodedMessage<Controller::GetDriverNameResponse>& _msg);
+ static void GetDeviceNameRequest(const ::fidl::DecodedMessage<Controller::GetDeviceNameRequest>& _msg);
+ static void GetDeviceNameResponse(const ::fidl::DecodedMessage<Controller::GetDeviceNameResponse>& _msg);
+ static void GetTopologicalPathRequest(const ::fidl::DecodedMessage<Controller::GetTopologicalPathRequest>& _msg);
+ static void GetTopologicalPathResponse(const ::fidl::DecodedMessage<Controller::GetTopologicalPathResponse>& _msg);
+ static void GetEventHandleRequest(const ::fidl::DecodedMessage<Controller::GetEventHandleRequest>& _msg);
+ static void GetEventHandleResponse(const ::fidl::DecodedMessage<Controller::GetEventHandleResponse>& _msg);
+ static void GetDriverLogFlagsRequest(const ::fidl::DecodedMessage<Controller::GetDriverLogFlagsRequest>& _msg);
+ static void GetDriverLogFlagsResponse(const ::fidl::DecodedMessage<Controller::GetDriverLogFlagsResponse>& _msg);
+ static void SetDriverLogFlagsRequest(const ::fidl::DecodedMessage<Controller::SetDriverLogFlagsRequest>& _msg);
+ static void SetDriverLogFlagsResponse(const ::fidl::DecodedMessage<Controller::SetDriverLogFlagsResponse>& _msg);
+ static void DebugResumeRequest(const ::fidl::DecodedMessage<Controller::DebugResumeRequest>& _msg);
+ static void DebugResumeResponse(const ::fidl::DecodedMessage<Controller::DebugResumeResponse>& _msg);
+ static void RunCompatibilityTestsRequest(const ::fidl::DecodedMessage<Controller::RunCompatibilityTestsRequest>& _msg);
+ static void RunCompatibilityTestsResponse(const ::fidl::DecodedMessage<Controller::RunCompatibilityTestsResponse>& _msg);
+ static void GetDevicePowerCapsRequest(const ::fidl::DecodedMessage<Controller::GetDevicePowerCapsRequest>& _msg);
+ static void GetDevicePowerCapsResponse(const ::fidl::DecodedMessage<Controller::GetDevicePowerCapsResponse>& _msg);
+ static void GetDevicePerformanceStatesRequest(const ::fidl::DecodedMessage<Controller::GetDevicePerformanceStatesRequest>& _msg);
+ static void GetDevicePerformanceStatesResponse(const ::fidl::DecodedMessage<Controller::GetDevicePerformanceStatesResponse>& _msg);
+ static void UpdatePowerStateMappingRequest(const ::fidl::DecodedMessage<Controller::UpdatePowerStateMappingRequest>& _msg);
+ static void UpdatePowerStateMappingResponse(const ::fidl::DecodedMessage<Controller::UpdatePowerStateMappingResponse>& _msg);
+ static void GetPowerStateMappingRequest(const ::fidl::DecodedMessage<Controller::GetPowerStateMappingRequest>& _msg);
+ static void GetPowerStateMappingResponse(const ::fidl::DecodedMessage<Controller::GetPowerStateMappingResponse>& _msg);
+ static void SuspendRequest(const ::fidl::DecodedMessage<Controller::SuspendRequest>& _msg);
+ static void SuspendResponse(const ::fidl::DecodedMessage<Controller::SuspendResponse>& _msg);
+ static void ResumeRequest(const ::fidl::DecodedMessage<Controller::ResumeRequest>& _msg);
+ static void ResumeResponse(const ::fidl::DecodedMessage<Controller::ResumeResponse>& _msg);
+ static void SetPerformanceStateRequest(const ::fidl::DecodedMessage<Controller::SetPerformanceStateRequest>& _msg);
+ static void SetPerformanceStateResponse(const ::fidl::DecodedMessage<Controller::SetPerformanceStateResponse>& _msg);
+ static void ConfigureAutoSuspendRequest(const ::fidl::DecodedMessage<Controller::ConfigureAutoSuspendRequest>& _msg);
+ static void ConfigureAutoSuspendResponse(const ::fidl::DecodedMessage<Controller::ConfigureAutoSuspendResponse>& _msg);
+ };
+};
+
+} // namespace device
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response, name) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response) == ::llcpp::fuchsia::device::NameProvider_GetDeviceName_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::NameProvider_GetDeviceName_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse)
+ == ::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::NameProvider::GetDeviceNameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::SystemPowerStateInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::SystemPowerStateInfo>);
+static_assert(offsetof(::llcpp::fuchsia::device::SystemPowerStateInfo, suspend_flag) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::SystemPowerStateInfo, wakeup_enable) == 4);
+static_assert(offsetof(::llcpp::fuchsia::device::SystemPowerStateInfo, dev_state) == 5);
+static_assert(sizeof(::llcpp::fuchsia::device::SystemPowerStateInfo) == ::llcpp::fuchsia::device::SystemPowerStateInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response, mapping) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response) == ::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetPowerStateMapping_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::DevicePowerStateInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::DevicePowerStateInfo>);
+static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, state_id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, is_supported) == 1);
+static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, restore_latency) == 8);
+static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, wakeup_capable) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::DevicePowerStateInfo, system_wake_state) == 20);
+static_assert(sizeof(::llcpp::fuchsia::device::DevicePowerStateInfo) == ::llcpp::fuchsia::device::DevicePowerStateInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response, dpstates) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response) == ::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetDevicePowerCaps_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_Resume_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Resume_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller_Resume_Response, out_state) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::Controller_Resume_Response) == ::llcpp::fuchsia::device::Controller_Resume_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_Resume_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Resume_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::DevicePerformanceStateInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::DevicePerformanceStateInfo>);
+static_assert(offsetof(::llcpp::fuchsia::device::DevicePerformanceStateInfo, state_id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::device::DevicePerformanceStateInfo, restore_latency) == 8);
+static_assert(offsetof(::llcpp::fuchsia::device::DevicePerformanceStateInfo, is_supported) == 16);
+static_assert(sizeof(::llcpp::fuchsia::device::DevicePerformanceStateInfo) == ::llcpp::fuchsia::device::DevicePerformanceStateInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response) == ::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_UpdatePowerStateMapping_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response) == ::llcpp::fuchsia::device::Controller_ScheduleUnbind_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_ScheduleUnbind_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_Rebind_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Rebind_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller_Rebind_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::Controller_Rebind_Response) == ::llcpp::fuchsia::device::Controller_Rebind_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_Rebind_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Rebind_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response, path) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response) == ::llcpp::fuchsia::device::Controller_GetTopologicalPath_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_GetTopologicalPath_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_Bind_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Bind_Response>);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller_Bind_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::device::Controller_Bind_Response) == ::llcpp::fuchsia::device::Controller_Bind_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller_Bind_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::device::Controller_Bind_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::BindRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::BindRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::BindRequest)
+ == ::llcpp::fuchsia::device::Controller::BindRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::BindRequest, driver) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::BindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::BindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::BindResponse)
+ == ::llcpp::fuchsia::device::Controller::BindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::BindResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::RebindRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::RebindRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::RebindRequest)
+ == ::llcpp::fuchsia::device::Controller::RebindRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::RebindRequest, driver) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::RebindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::RebindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::RebindResponse)
+ == ::llcpp::fuchsia::device::Controller::RebindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::RebindResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse)
+ == ::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::ScheduleUnbindResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDriverNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDriverNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDriverNameResponse)
+ == ::llcpp::fuchsia::device::Controller::GetDriverNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDriverNameResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDriverNameResponse, name) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDeviceNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDeviceNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDeviceNameResponse)
+ == ::llcpp::fuchsia::device::Controller::GetDeviceNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDeviceNameResponse, name) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse)
+ == ::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetTopologicalPathResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::GetEventHandleResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetEventHandleResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetEventHandleResponse)
+ == ::llcpp::fuchsia::device::Controller::GetEventHandleResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetEventHandleResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetEventHandleResponse, event) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse)
+ == ::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDriverLogFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest)
+ == ::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest, clear_flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsRequest, set_flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse)
+ == ::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetDriverLogFlagsResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::DebugResumeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::DebugResumeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::DebugResumeResponse)
+ == ::llcpp::fuchsia::device::Controller::DebugResumeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::DebugResumeResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest)
+ == ::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::RunCompatibilityTestsRequest, hook_wait_time) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse)
+ == ::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::RunCompatibilityTestsResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse)
+ == ::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDevicePowerCapsResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse)
+ == ::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse, states) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetDevicePerformanceStatesResponse, status) == 496);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest)
+ == ::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingRequest, mapping) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse)
+ == ::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::UpdatePowerStateMappingResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse)
+ == ::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::GetPowerStateMappingResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::SuspendRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SuspendRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::SuspendRequest)
+ == ::llcpp::fuchsia::device::Controller::SuspendRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SuspendRequest, requested_state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::SuspendResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SuspendResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::SuspendResponse)
+ == ::llcpp::fuchsia::device::Controller::SuspendResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SuspendResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SuspendResponse, out_state) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::ResumeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ResumeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::ResumeRequest)
+ == ::llcpp::fuchsia::device::Controller::ResumeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::ResumeRequest, requested_state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::ResumeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ResumeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::ResumeResponse)
+ == ::llcpp::fuchsia::device::Controller::ResumeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::ResumeResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest)
+ == ::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetPerformanceStateRequest, requested_state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse)
+ == ::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::SetPerformanceStateResponse, out_state) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest)
+ == ::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest, enable) == 16);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendRequest, requested_deepest_sleep_state) == 17);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse)
+ == ::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::device::Controller::ConfigureAutoSuspendResponse, status) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-exception/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-exception/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..5647533
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-exception/gen/llcpp/fidl.cc
@@ -0,0 +1,1406 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/exception/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace exception {
+
+void ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(ProcessLimbo_RemoveFilters_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(ProcessLimbo_RemoveFilters_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(ProcessLimbo_RemoveFilters_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(ProcessLimbo_ReleaseProcess_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(ProcessLimbo_ReleaseProcess_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(ProcessLimbo_ReleaseProcess_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(ProcessLimbo_AppendFilters_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(ProcessLimbo_AppendFilters_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(ProcessLimbo_AppendFilters_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kHandler_OnException_Ordinal = 0x7ec50e5a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kHandler_OnException_GenOrdinal = 0x5de09d36098de59elu;
+extern "C" const fidl_type_t v1_fuchsia_exception_HandlerOnExceptionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_HandlerOnExceptionResponseTable;
+
+} // namespace
+template <>
+Handler::ResultOf::OnException_Impl<Handler::OnExceptionResponse>::OnException_Impl(::zx::unowned_channel _client_end, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnExceptionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, OnExceptionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OnExceptionRequest*>(_write_bytes);
+ _request.exception = std::move(exception);
+ _request.info = std::move(info);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnExceptionRequest));
+ ::fidl::DecodedMessage<OnExceptionRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Handler::InPlace::OnException(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Handler::ResultOf::OnException Handler::SyncClient::OnException(::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info) {
+ return ResultOf::OnException(::zx::unowned_channel(this->channel_), std::move(exception), std::move(info));
+}
+
+Handler::ResultOf::OnException Handler::Call::OnException(::zx::unowned_channel _client_end, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info) {
+ return ResultOf::OnException(std::move(_client_end), std::move(exception), std::move(info));
+}
+
+template <>
+Handler::UnownedResultOf::OnException_Impl<Handler::OnExceptionResponse>::OnException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < OnExceptionRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<OnExceptionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, OnExceptionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OnExceptionRequest*>(_request_buffer.data());
+ _request.exception = std::move(exception);
+ _request.info = std::move(info);
+ _request_buffer.set_actual(sizeof(OnExceptionRequest));
+ ::fidl::DecodedMessage<OnExceptionRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Handler::InPlace::OnException(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Handler::UnownedResultOf::OnException Handler::SyncClient::OnException(::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OnException(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(exception), std::move(info), std::move(_response_buffer));
+}
+
+Handler::UnownedResultOf::OnException Handler::Call::OnException(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OnException(std::move(_client_end), std::move(_request_buffer), std::move(exception), std::move(info), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Handler::OnExceptionResponse> Handler::InPlace::OnException(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnExceptionRequest> params, ::fidl::BytePart response_buffer) {
+ Handler::SetTransactionHeaderFor::OnExceptionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Handler::OnExceptionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<OnExceptionRequest, OnExceptionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Handler::OnExceptionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Handler::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kHandler_OnException_Ordinal:
+ case kHandler_OnException_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnExceptionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OnException(std::move(message->exception), std::move(message->info),
+ Interface::OnExceptionCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Handler::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Handler::Interface::OnExceptionCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnExceptionResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<OnExceptionResponse*>(_write_bytes);
+ Handler::SetTransactionHeaderFor::OnExceptionResponse(
+ ::fidl::DecodedMessage<OnExceptionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnExceptionResponse::PrimarySize,
+ OnExceptionResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnExceptionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<OnExceptionResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Handler::SetTransactionHeaderFor::OnExceptionRequest(const ::fidl::DecodedMessage<Handler::OnExceptionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kHandler_OnException_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Handler::SetTransactionHeaderFor::OnExceptionResponse(const ::fidl::DecodedMessage<Handler::OnExceptionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kHandler_OnException_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+::llcpp::fuchsia::exception::ProcessExceptionMetadata::Builder ProcessExceptionMetadata::Build() {
+ return ProcessExceptionMetadata::Builder();
+}
+
+auto ::llcpp::fuchsia::exception::ProcessExceptionMetadata::Builder::set_info(::llcpp::fuchsia::exception::ExceptionInfo* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::exception::ProcessExceptionMetadata::Builder::set_process(::zx::process* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::exception::ProcessExceptionMetadata::Builder::set_thread(::zx::thread* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(ProcessLimbo_WatchProcessesWaitingOnException_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(ProcessLimbo_WatchProcessesWaitingOnException_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(ProcessLimbo_WatchProcessesWaitingOnException_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::exception::ProcessException::Builder ProcessException::Build() {
+ return ProcessException::Builder();
+}
+
+auto ::llcpp::fuchsia::exception::ProcessException::Builder::set_exception(::zx::exception* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::exception::ProcessException::Builder::set_info(::llcpp::fuchsia::exception::ExceptionInfo* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::exception::ProcessException::Builder::set_process(::zx::process* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::exception::ProcessException::Builder::set_thread(::zx::thread* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(ProcessLimbo_RetrieveException_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(ProcessLimbo_RetrieveException_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(ProcessLimbo_RetrieveException_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_SetActive_Ordinal = 0x1d6dc50c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_SetActive_GenOrdinal = 0x54c8d03fab29fb35lu;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboSetActiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboSetActiveResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_WatchActive_Ordinal = 0x5400259f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_WatchActive_GenOrdinal = 0x7b4c6602af289428lu;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchActiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchActiveResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_WatchProcessesWaitingOnException_Ordinal = 0x5c132e1100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_WatchProcessesWaitingOnException_GenOrdinal = 0xfd5105138d612a3lu;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_RetrieveException_Ordinal = 0x47ad466f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_RetrieveException_GenOrdinal = 0x6ee2df26d6e0444blu;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRetrieveExceptionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRetrieveExceptionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_ReleaseProcess_Ordinal = 0x7adea12100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_ReleaseProcess_GenOrdinal = 0x76911553fea22b87lu;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboReleaseProcessRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboReleaseProcessResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_AppendFilters_Ordinal = 0x49c3fc8800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_AppendFilters_GenOrdinal = 0x16a292988604df9alu;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboAppendFiltersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboAppendFiltersResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_RemoveFilters_Ordinal = 0xfe8829500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_RemoveFilters_GenOrdinal = 0x1fae63a1df648aelu;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRemoveFiltersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRemoveFiltersResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_GetFilters_Ordinal = 0x4410733300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProcessLimbo_GetFilters_GenOrdinal = 0x11d2a683823e7de6lu;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboGetFiltersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboGetFiltersResponseTable;
+
+} // namespace
+template <>
+ProcessLimbo::ResultOf::SetActive_Impl<ProcessLimbo::SetActiveResponse>::SetActive_Impl(::zx::unowned_channel _client_end, bool active) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetActiveRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetActiveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetActiveRequest*>(_write_bytes);
+ _request.active = std::move(active);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetActiveRequest));
+ ::fidl::DecodedMessage<SetActiveRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ ProcessLimbo::InPlace::SetActive(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+ProcessLimbo::ResultOf::SetActive ProcessLimbo::SyncClient::SetActive(bool active) {
+ return ResultOf::SetActive(::zx::unowned_channel(this->channel_), std::move(active));
+}
+
+ProcessLimbo::ResultOf::SetActive ProcessLimbo::Call::SetActive(::zx::unowned_channel _client_end, bool active) {
+ return ResultOf::SetActive(std::move(_client_end), std::move(active));
+}
+
+template <>
+ProcessLimbo::UnownedResultOf::SetActive_Impl<ProcessLimbo::SetActiveResponse>::SetActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetActiveRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetActiveResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetActiveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetActiveRequest*>(_request_buffer.data());
+ _request.active = std::move(active);
+ _request_buffer.set_actual(sizeof(SetActiveRequest));
+ ::fidl::DecodedMessage<SetActiveRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ ProcessLimbo::InPlace::SetActive(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+ProcessLimbo::UnownedResultOf::SetActive ProcessLimbo::SyncClient::SetActive(::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetActive(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(active), std::move(_response_buffer));
+}
+
+ProcessLimbo::UnownedResultOf::SetActive ProcessLimbo::Call::SetActive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetActive(std::move(_client_end), std::move(_request_buffer), std::move(active), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ProcessLimbo::SetActiveResponse> ProcessLimbo::InPlace::SetActive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetActiveRequest> params, ::fidl::BytePart response_buffer) {
+ ProcessLimbo::SetTransactionHeaderFor::SetActiveRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::SetActiveResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetActiveRequest, SetActiveResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::SetActiveResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+ProcessLimbo::ResultOf::WatchActive_Impl<ProcessLimbo::WatchActiveResponse>::WatchActive_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchActiveRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchActiveRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchActiveRequest));
+ ::fidl::DecodedMessage<WatchActiveRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ ProcessLimbo::InPlace::WatchActive(std::move(_client_end), Super::response_buffer()));
+}
+
+ProcessLimbo::ResultOf::WatchActive ProcessLimbo::SyncClient::WatchActive() {
+ return ResultOf::WatchActive(::zx::unowned_channel(this->channel_));
+}
+
+ProcessLimbo::ResultOf::WatchActive ProcessLimbo::Call::WatchActive(::zx::unowned_channel _client_end) {
+ return ResultOf::WatchActive(std::move(_client_end));
+}
+
+template <>
+ProcessLimbo::UnownedResultOf::WatchActive_Impl<ProcessLimbo::WatchActiveResponse>::WatchActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WatchActiveRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WatchActiveRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WatchActiveRequest));
+ ::fidl::DecodedMessage<WatchActiveRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ ProcessLimbo::InPlace::WatchActive(std::move(_client_end), std::move(_response_buffer)));
+}
+
+ProcessLimbo::UnownedResultOf::WatchActive ProcessLimbo::SyncClient::WatchActive(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchActive(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+ProcessLimbo::UnownedResultOf::WatchActive ProcessLimbo::Call::WatchActive(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchActive(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ProcessLimbo::WatchActiveResponse> ProcessLimbo::InPlace::WatchActive(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WatchActiveRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WatchActiveRequest> params(std::move(_request_buffer));
+ ProcessLimbo::SetTransactionHeaderFor::WatchActiveRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::WatchActiveResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchActiveRequest, WatchActiveResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::WatchActiveResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+ProcessLimbo::ResultOf::WatchProcessesWaitingOnException_Impl<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>::WatchProcessesWaitingOnException_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchProcessesWaitingOnExceptionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchProcessesWaitingOnExceptionRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchProcessesWaitingOnExceptionRequest));
+ ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ ProcessLimbo::InPlace::WatchProcessesWaitingOnException(std::move(_client_end), Super::response_buffer()));
+}
+
+ProcessLimbo::ResultOf::WatchProcessesWaitingOnException ProcessLimbo::SyncClient::WatchProcessesWaitingOnException() {
+ return ResultOf::WatchProcessesWaitingOnException(::zx::unowned_channel(this->channel_));
+}
+
+ProcessLimbo::ResultOf::WatchProcessesWaitingOnException ProcessLimbo::Call::WatchProcessesWaitingOnException(::zx::unowned_channel _client_end) {
+ return ResultOf::WatchProcessesWaitingOnException(std::move(_client_end));
+}
+
+template <>
+ProcessLimbo::UnownedResultOf::WatchProcessesWaitingOnException_Impl<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>::WatchProcessesWaitingOnException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WatchProcessesWaitingOnExceptionRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WatchProcessesWaitingOnExceptionRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WatchProcessesWaitingOnExceptionRequest));
+ ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ ProcessLimbo::InPlace::WatchProcessesWaitingOnException(std::move(_client_end), std::move(_response_buffer)));
+}
+
+ProcessLimbo::UnownedResultOf::WatchProcessesWaitingOnException ProcessLimbo::SyncClient::WatchProcessesWaitingOnException(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchProcessesWaitingOnException(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+ProcessLimbo::UnownedResultOf::WatchProcessesWaitingOnException ProcessLimbo::Call::WatchProcessesWaitingOnException(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchProcessesWaitingOnException(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse> ProcessLimbo::InPlace::WatchProcessesWaitingOnException(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WatchProcessesWaitingOnExceptionRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionRequest> params(std::move(_request_buffer));
+ ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchProcessesWaitingOnExceptionRequest, WatchProcessesWaitingOnExceptionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+ProcessLimbo::ResultOf::RetrieveException_Impl<ProcessLimbo::RetrieveExceptionResponse>::RetrieveException_Impl(::zx::unowned_channel _client_end, uint64_t process_koid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RetrieveExceptionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RetrieveExceptionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RetrieveExceptionRequest*>(_write_bytes);
+ _request.process_koid = std::move(process_koid);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RetrieveExceptionRequest));
+ ::fidl::DecodedMessage<RetrieveExceptionRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ ProcessLimbo::InPlace::RetrieveException(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+ProcessLimbo::ResultOf::RetrieveException ProcessLimbo::SyncClient::RetrieveException(uint64_t process_koid) {
+ return ResultOf::RetrieveException(::zx::unowned_channel(this->channel_), std::move(process_koid));
+}
+
+ProcessLimbo::ResultOf::RetrieveException ProcessLimbo::Call::RetrieveException(::zx::unowned_channel _client_end, uint64_t process_koid) {
+ return ResultOf::RetrieveException(std::move(_client_end), std::move(process_koid));
+}
+
+template <>
+ProcessLimbo::UnownedResultOf::RetrieveException_Impl<ProcessLimbo::RetrieveExceptionResponse>::RetrieveException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RetrieveExceptionRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RetrieveExceptionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RetrieveExceptionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RetrieveExceptionRequest*>(_request_buffer.data());
+ _request.process_koid = std::move(process_koid);
+ _request_buffer.set_actual(sizeof(RetrieveExceptionRequest));
+ ::fidl::DecodedMessage<RetrieveExceptionRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ ProcessLimbo::InPlace::RetrieveException(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+ProcessLimbo::UnownedResultOf::RetrieveException ProcessLimbo::SyncClient::RetrieveException(::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RetrieveException(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(process_koid), std::move(_response_buffer));
+}
+
+ProcessLimbo::UnownedResultOf::RetrieveException ProcessLimbo::Call::RetrieveException(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RetrieveException(std::move(_client_end), std::move(_request_buffer), std::move(process_koid), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ProcessLimbo::RetrieveExceptionResponse> ProcessLimbo::InPlace::RetrieveException(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RetrieveExceptionRequest> params, ::fidl::BytePart response_buffer) {
+ ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::RetrieveExceptionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RetrieveExceptionRequest, RetrieveExceptionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::RetrieveExceptionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+ProcessLimbo::ResultOf::ReleaseProcess_Impl<ProcessLimbo::ReleaseProcessResponse>::ReleaseProcess_Impl(::zx::unowned_channel _client_end, uint64_t process_koid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseProcessRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReleaseProcessRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseProcessRequest*>(_write_bytes);
+ _request.process_koid = std::move(process_koid);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReleaseProcessRequest));
+ ::fidl::DecodedMessage<ReleaseProcessRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ ProcessLimbo::InPlace::ReleaseProcess(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+ProcessLimbo::ResultOf::ReleaseProcess ProcessLimbo::SyncClient::ReleaseProcess(uint64_t process_koid) {
+ return ResultOf::ReleaseProcess(::zx::unowned_channel(this->channel_), std::move(process_koid));
+}
+
+ProcessLimbo::ResultOf::ReleaseProcess ProcessLimbo::Call::ReleaseProcess(::zx::unowned_channel _client_end, uint64_t process_koid) {
+ return ResultOf::ReleaseProcess(std::move(_client_end), std::move(process_koid));
+}
+
+template <>
+ProcessLimbo::UnownedResultOf::ReleaseProcess_Impl<ProcessLimbo::ReleaseProcessResponse>::ReleaseProcess_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReleaseProcessRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReleaseProcessResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReleaseProcessRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseProcessRequest*>(_request_buffer.data());
+ _request.process_koid = std::move(process_koid);
+ _request_buffer.set_actual(sizeof(ReleaseProcessRequest));
+ ::fidl::DecodedMessage<ReleaseProcessRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ ProcessLimbo::InPlace::ReleaseProcess(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+ProcessLimbo::UnownedResultOf::ReleaseProcess ProcessLimbo::SyncClient::ReleaseProcess(::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReleaseProcess(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(process_koid), std::move(_response_buffer));
+}
+
+ProcessLimbo::UnownedResultOf::ReleaseProcess ProcessLimbo::Call::ReleaseProcess(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReleaseProcess(std::move(_client_end), std::move(_request_buffer), std::move(process_koid), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ProcessLimbo::ReleaseProcessResponse> ProcessLimbo::InPlace::ReleaseProcess(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseProcessRequest> params, ::fidl::BytePart response_buffer) {
+ ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::ReleaseProcessResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReleaseProcessRequest, ReleaseProcessResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::ReleaseProcessResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+ProcessLimbo::ResultOf::AppendFilters_Impl<ProcessLimbo::AppendFiltersResponse>::AppendFilters_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AppendFiltersRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AppendFiltersRequest _request = {};
+ _request.filters = std::move(filters);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AppendFiltersRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ ProcessLimbo::InPlace::AppendFilters(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+ProcessLimbo::ResultOf::AppendFilters ProcessLimbo::SyncClient::AppendFilters(::fidl::VectorView<::fidl::StringView> filters) {
+ return ResultOf::AppendFilters(::zx::unowned_channel(this->channel_), std::move(filters));
+}
+
+ProcessLimbo::ResultOf::AppendFilters ProcessLimbo::Call::AppendFilters(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters) {
+ return ResultOf::AppendFilters(std::move(_client_end), std::move(filters));
+}
+
+template <>
+ProcessLimbo::UnownedResultOf::AppendFilters_Impl<ProcessLimbo::AppendFiltersResponse>::AppendFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AppendFiltersRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AppendFiltersResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ AppendFiltersRequest _request = {};
+ _request.filters = std::move(filters);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AppendFiltersRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ ProcessLimbo::InPlace::AppendFilters(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+ProcessLimbo::UnownedResultOf::AppendFilters ProcessLimbo::SyncClient::AppendFilters(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AppendFilters(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(filters), std::move(_response_buffer));
+}
+
+ProcessLimbo::UnownedResultOf::AppendFilters ProcessLimbo::Call::AppendFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AppendFilters(std::move(_client_end), std::move(_request_buffer), std::move(filters), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ProcessLimbo::AppendFiltersResponse> ProcessLimbo::InPlace::AppendFilters(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AppendFiltersRequest> params, ::fidl::BytePart response_buffer) {
+ ProcessLimbo::SetTransactionHeaderFor::AppendFiltersRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::AppendFiltersResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AppendFiltersRequest, AppendFiltersResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::AppendFiltersResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+ProcessLimbo::ResultOf::RemoveFilters_Impl<ProcessLimbo::RemoveFiltersResponse>::RemoveFilters_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveFiltersRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ RemoveFiltersRequest _request = {};
+ _request.filters = std::move(filters);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RemoveFiltersRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ ProcessLimbo::InPlace::RemoveFilters(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+ProcessLimbo::ResultOf::RemoveFilters ProcessLimbo::SyncClient::RemoveFilters(::fidl::VectorView<::fidl::StringView> filters) {
+ return ResultOf::RemoveFilters(::zx::unowned_channel(this->channel_), std::move(filters));
+}
+
+ProcessLimbo::ResultOf::RemoveFilters ProcessLimbo::Call::RemoveFilters(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters) {
+ return ResultOf::RemoveFilters(std::move(_client_end), std::move(filters));
+}
+
+template <>
+ProcessLimbo::UnownedResultOf::RemoveFilters_Impl<ProcessLimbo::RemoveFiltersResponse>::RemoveFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RemoveFiltersRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RemoveFiltersResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ RemoveFiltersRequest _request = {};
+ _request.filters = std::move(filters);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RemoveFiltersRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ ProcessLimbo::InPlace::RemoveFilters(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+ProcessLimbo::UnownedResultOf::RemoveFilters ProcessLimbo::SyncClient::RemoveFilters(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RemoveFilters(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(filters), std::move(_response_buffer));
+}
+
+ProcessLimbo::UnownedResultOf::RemoveFilters ProcessLimbo::Call::RemoveFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RemoveFilters(std::move(_client_end), std::move(_request_buffer), std::move(filters), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ProcessLimbo::RemoveFiltersResponse> ProcessLimbo::InPlace::RemoveFilters(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RemoveFiltersRequest> params, ::fidl::BytePart response_buffer) {
+ ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::RemoveFiltersResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RemoveFiltersRequest, RemoveFiltersResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::RemoveFiltersResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+ProcessLimbo::ResultOf::GetFilters_Impl<ProcessLimbo::GetFiltersResponse>::GetFilters_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFiltersRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFiltersRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFiltersRequest));
+ ::fidl::DecodedMessage<GetFiltersRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ ProcessLimbo::InPlace::GetFilters(std::move(_client_end), Super::response_buffer()));
+}
+
+ProcessLimbo::ResultOf::GetFilters ProcessLimbo::SyncClient::GetFilters() {
+ return ResultOf::GetFilters(::zx::unowned_channel(this->channel_));
+}
+
+ProcessLimbo::ResultOf::GetFilters ProcessLimbo::Call::GetFilters(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFilters(std::move(_client_end));
+}
+
+template <>
+ProcessLimbo::UnownedResultOf::GetFilters_Impl<ProcessLimbo::GetFiltersResponse>::GetFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFiltersRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFiltersRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFiltersRequest));
+ ::fidl::DecodedMessage<GetFiltersRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ ProcessLimbo::InPlace::GetFilters(std::move(_client_end), std::move(_response_buffer)));
+}
+
+ProcessLimbo::UnownedResultOf::GetFilters ProcessLimbo::SyncClient::GetFilters(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFilters(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+ProcessLimbo::UnownedResultOf::GetFilters ProcessLimbo::Call::GetFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFilters(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ProcessLimbo::GetFiltersResponse> ProcessLimbo::InPlace::GetFilters(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFiltersRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFiltersRequest> params(std::move(_request_buffer));
+ ProcessLimbo::SetTransactionHeaderFor::GetFiltersRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::GetFiltersResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFiltersRequest, GetFiltersResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ProcessLimbo::GetFiltersResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool ProcessLimbo::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kProcessLimbo_SetActive_Ordinal:
+ case kProcessLimbo_SetActive_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetActiveRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetActive(std::move(message->active),
+ Interface::SetActiveCompleter::Sync(txn));
+ return true;
+ }
+ case kProcessLimbo_WatchActive_Ordinal:
+ case kProcessLimbo_WatchActive_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchActiveRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WatchActive(
+ Interface::WatchActiveCompleter::Sync(txn));
+ return true;
+ }
+ case kProcessLimbo_WatchProcessesWaitingOnException_Ordinal:
+ case kProcessLimbo_WatchProcessesWaitingOnException_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchProcessesWaitingOnExceptionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WatchProcessesWaitingOnException(
+ Interface::WatchProcessesWaitingOnExceptionCompleter::Sync(txn));
+ return true;
+ }
+ case kProcessLimbo_RetrieveException_Ordinal:
+ case kProcessLimbo_RetrieveException_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RetrieveExceptionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RetrieveException(std::move(message->process_koid),
+ Interface::RetrieveExceptionCompleter::Sync(txn));
+ return true;
+ }
+ case kProcessLimbo_ReleaseProcess_Ordinal:
+ case kProcessLimbo_ReleaseProcess_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReleaseProcessRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReleaseProcess(std::move(message->process_koid),
+ Interface::ReleaseProcessCompleter::Sync(txn));
+ return true;
+ }
+ case kProcessLimbo_AppendFilters_Ordinal:
+ case kProcessLimbo_AppendFilters_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AppendFiltersRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AppendFilters(std::move(message->filters),
+ Interface::AppendFiltersCompleter::Sync(txn));
+ return true;
+ }
+ case kProcessLimbo_RemoveFilters_Ordinal:
+ case kProcessLimbo_RemoveFilters_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RemoveFiltersRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RemoveFilters(std::move(message->filters),
+ Interface::RemoveFiltersCompleter::Sync(txn));
+ return true;
+ }
+ case kProcessLimbo_GetFilters_Ordinal:
+ case kProcessLimbo_GetFilters_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFiltersRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFilters(
+ Interface::GetFiltersCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool ProcessLimbo::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void ProcessLimbo::Interface::SetActiveCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetActiveResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetActiveResponse*>(_write_bytes);
+ ProcessLimbo::SetTransactionHeaderFor::SetActiveResponse(
+ ::fidl::DecodedMessage<SetActiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetActiveResponse::PrimarySize,
+ SetActiveResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetActiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetActiveResponse>(std::move(_response_bytes)));
+}
+
+
+void ProcessLimbo::Interface::WatchActiveCompleterBase::Reply(bool is_active) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchActiveResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WatchActiveResponse*>(_write_bytes);
+ ProcessLimbo::SetTransactionHeaderFor::WatchActiveResponse(
+ ::fidl::DecodedMessage<WatchActiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchActiveResponse::PrimarySize,
+ WatchActiveResponse::PrimarySize)));
+ _response.is_active = std::move(is_active);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchActiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchActiveResponse>(std::move(_response_bytes)));
+}
+
+void ProcessLimbo::Interface::WatchActiveCompleterBase::Reply(::fidl::BytePart _buffer, bool is_active) {
+ if (_buffer.capacity() < WatchActiveResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WatchActiveResponse*>(_buffer.data());
+ ProcessLimbo::SetTransactionHeaderFor::WatchActiveResponse(
+ ::fidl::DecodedMessage<WatchActiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchActiveResponse::PrimarySize,
+ WatchActiveResponse::PrimarySize)));
+ _response.is_active = std::move(is_active);
+ _buffer.set_actual(sizeof(WatchActiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchActiveResponse>(std::move(_buffer)));
+}
+
+void ProcessLimbo::Interface::WatchActiveCompleterBase::Reply(::fidl::DecodedMessage<WatchActiveResponse> params) {
+ ProcessLimbo::SetTransactionHeaderFor::WatchActiveResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchProcessesWaitingOnExceptionResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ WatchProcessesWaitingOnExceptionResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionResponse(
+ ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchProcessesWaitingOnExceptionResponse::PrimarySize,
+ WatchProcessesWaitingOnExceptionResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::ReplySuccess(::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list) {
+ ProcessLimbo_WatchProcessesWaitingOnException_Response response;
+ response.exception_list = std::move(exception_list);
+
+ Reply(ProcessLimbo_WatchProcessesWaitingOnException_Result::WithResponse(&response));
+}
+void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::ReplyError(int32_t error) {
+ Reply(ProcessLimbo_WatchProcessesWaitingOnException_Result::WithErr(&error));
+}
+
+void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result) {
+ if (_buffer.capacity() < WatchProcessesWaitingOnExceptionResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WatchProcessesWaitingOnExceptionResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionResponse(
+ ::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchProcessesWaitingOnExceptionResponse::PrimarySize,
+ WatchProcessesWaitingOnExceptionResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list) {
+ ProcessLimbo_WatchProcessesWaitingOnException_Response response;
+ response.exception_list = std::move(exception_list);
+
+ Reply(std::move(_buffer), ProcessLimbo_WatchProcessesWaitingOnException_Result::WithResponse(&response));
+}
+
+void ProcessLimbo::Interface::WatchProcessesWaitingOnExceptionCompleterBase::Reply(::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionResponse> params) {
+ ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RetrieveExceptionResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ RetrieveExceptionResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionResponse(
+ ::fidl::DecodedMessage<RetrieveExceptionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RetrieveExceptionResponse::PrimarySize,
+ RetrieveExceptionResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::ReplySuccess(::llcpp::fuchsia::exception::ProcessException process_exception) {
+ ProcessLimbo_RetrieveException_Response response;
+ response.process_exception = std::move(process_exception);
+
+ Reply(ProcessLimbo_RetrieveException_Result::WithResponse(&response));
+}
+void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::ReplyError(int32_t error) {
+ Reply(ProcessLimbo_RetrieveException_Result::WithErr(&error));
+}
+
+void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result) {
+ if (_buffer.capacity() < RetrieveExceptionResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RetrieveExceptionResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionResponse(
+ ::fidl::DecodedMessage<RetrieveExceptionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RetrieveExceptionResponse::PrimarySize,
+ RetrieveExceptionResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessException process_exception) {
+ ProcessLimbo_RetrieveException_Response response;
+ response.process_exception = std::move(process_exception);
+
+ Reply(std::move(_buffer), ProcessLimbo_RetrieveException_Result::WithResponse(&response));
+}
+
+void ProcessLimbo::Interface::RetrieveExceptionCompleterBase::Reply(::fidl::DecodedMessage<RetrieveExceptionResponse> params) {
+ ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void ProcessLimbo::Interface::ReleaseProcessCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseProcessResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ReleaseProcessResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessResponse(
+ ::fidl::DecodedMessage<ReleaseProcessResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReleaseProcessResponse::PrimarySize,
+ ReleaseProcessResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::ReleaseProcessCompleterBase::ReplySuccess() {
+ ProcessLimbo_ReleaseProcess_Response response;
+
+ Reply(ProcessLimbo_ReleaseProcess_Result::WithResponse(&response));
+}
+void ProcessLimbo::Interface::ReleaseProcessCompleterBase::ReplyError(int32_t error) {
+ Reply(ProcessLimbo_ReleaseProcess_Result::WithErr(&error));
+}
+
+void ProcessLimbo::Interface::ReleaseProcessCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result) {
+ if (_buffer.capacity() < ReleaseProcessResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReleaseProcessResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessResponse(
+ ::fidl::DecodedMessage<ReleaseProcessResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReleaseProcessResponse::PrimarySize,
+ ReleaseProcessResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::ReleaseProcessCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ ProcessLimbo_ReleaseProcess_Response response;
+
+ Reply(std::move(_buffer), ProcessLimbo_ReleaseProcess_Result::WithResponse(&response));
+}
+
+void ProcessLimbo::Interface::ReleaseProcessCompleterBase::Reply(::fidl::DecodedMessage<ReleaseProcessResponse> params) {
+ ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void ProcessLimbo::Interface::AppendFiltersCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AppendFiltersResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AppendFiltersResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::AppendFiltersResponse(
+ ::fidl::DecodedMessage<AppendFiltersResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AppendFiltersResponse::PrimarySize,
+ AppendFiltersResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::AppendFiltersCompleterBase::ReplySuccess() {
+ ProcessLimbo_AppendFilters_Response response;
+
+ Reply(ProcessLimbo_AppendFilters_Result::WithResponse(&response));
+}
+void ProcessLimbo::Interface::AppendFiltersCompleterBase::ReplyError(int32_t error) {
+ Reply(ProcessLimbo_AppendFilters_Result::WithErr(&error));
+}
+
+void ProcessLimbo::Interface::AppendFiltersCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result) {
+ if (_buffer.capacity() < AppendFiltersResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AppendFiltersResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::AppendFiltersResponse(
+ ::fidl::DecodedMessage<AppendFiltersResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AppendFiltersResponse::PrimarySize,
+ AppendFiltersResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::AppendFiltersCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ ProcessLimbo_AppendFilters_Response response;
+
+ Reply(std::move(_buffer), ProcessLimbo_AppendFilters_Result::WithResponse(&response));
+}
+
+void ProcessLimbo::Interface::AppendFiltersCompleterBase::Reply(::fidl::DecodedMessage<AppendFiltersResponse> params) {
+ ProcessLimbo::SetTransactionHeaderFor::AppendFiltersResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void ProcessLimbo::Interface::RemoveFiltersCompleterBase::Reply(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveFiltersResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ RemoveFiltersResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersResponse(
+ ::fidl::DecodedMessage<RemoveFiltersResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RemoveFiltersResponse::PrimarySize,
+ RemoveFiltersResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::RemoveFiltersCompleterBase::ReplySuccess() {
+ ProcessLimbo_RemoveFilters_Response response;
+
+ Reply(ProcessLimbo_RemoveFilters_Result::WithResponse(&response));
+}
+void ProcessLimbo::Interface::RemoveFiltersCompleterBase::ReplyError(int32_t error) {
+ Reply(ProcessLimbo_RemoveFilters_Result::WithErr(&error));
+}
+
+void ProcessLimbo::Interface::RemoveFiltersCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result) {
+ if (_buffer.capacity() < RemoveFiltersResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RemoveFiltersResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersResponse(
+ ::fidl::DecodedMessage<RemoveFiltersResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RemoveFiltersResponse::PrimarySize,
+ RemoveFiltersResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void ProcessLimbo::Interface::RemoveFiltersCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ ProcessLimbo_RemoveFilters_Response response;
+
+ Reply(std::move(_buffer), ProcessLimbo_RemoveFilters_Result::WithResponse(&response));
+}
+
+void ProcessLimbo::Interface::RemoveFiltersCompleterBase::Reply(::fidl::DecodedMessage<RemoveFiltersResponse> params) {
+ ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void ProcessLimbo::Interface::GetFiltersCompleterBase::Reply(::fidl::VectorView<::fidl::StringView> filters) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFiltersResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetFiltersResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::GetFiltersResponse(
+ ::fidl::DecodedMessage<GetFiltersResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFiltersResponse::PrimarySize,
+ GetFiltersResponse::PrimarySize)));
+ _response.filters = std::move(filters);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void ProcessLimbo::Interface::GetFiltersCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::fidl::StringView> filters) {
+ if (_buffer.capacity() < GetFiltersResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetFiltersResponse _response = {};
+ ProcessLimbo::SetTransactionHeaderFor::GetFiltersResponse(
+ ::fidl::DecodedMessage<GetFiltersResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFiltersResponse::PrimarySize,
+ GetFiltersResponse::PrimarySize)));
+ _response.filters = std::move(filters);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void ProcessLimbo::Interface::GetFiltersCompleterBase::Reply(::fidl::DecodedMessage<GetFiltersResponse> params) {
+ ProcessLimbo::SetTransactionHeaderFor::GetFiltersResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void ProcessLimbo::SetTransactionHeaderFor::SetActiveRequest(const ::fidl::DecodedMessage<ProcessLimbo::SetActiveRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_SetActive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ProcessLimbo::SetTransactionHeaderFor::SetActiveResponse(const ::fidl::DecodedMessage<ProcessLimbo::SetActiveResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_SetActive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ProcessLimbo::SetTransactionHeaderFor::WatchActiveRequest(const ::fidl::DecodedMessage<ProcessLimbo::WatchActiveRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_WatchActive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ProcessLimbo::SetTransactionHeaderFor::WatchActiveResponse(const ::fidl::DecodedMessage<ProcessLimbo::WatchActiveResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_WatchActive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionRequest(const ::fidl::DecodedMessage<ProcessLimbo::WatchProcessesWaitingOnExceptionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_WatchProcessesWaitingOnException_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ProcessLimbo::SetTransactionHeaderFor::WatchProcessesWaitingOnExceptionResponse(const ::fidl::DecodedMessage<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_WatchProcessesWaitingOnException_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionRequest(const ::fidl::DecodedMessage<ProcessLimbo::RetrieveExceptionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_RetrieveException_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ProcessLimbo::SetTransactionHeaderFor::RetrieveExceptionResponse(const ::fidl::DecodedMessage<ProcessLimbo::RetrieveExceptionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_RetrieveException_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessRequest(const ::fidl::DecodedMessage<ProcessLimbo::ReleaseProcessRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_ReleaseProcess_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ProcessLimbo::SetTransactionHeaderFor::ReleaseProcessResponse(const ::fidl::DecodedMessage<ProcessLimbo::ReleaseProcessResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_ReleaseProcess_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ProcessLimbo::SetTransactionHeaderFor::AppendFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::AppendFiltersRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_AppendFilters_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ProcessLimbo::SetTransactionHeaderFor::AppendFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::AppendFiltersResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_AppendFilters_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::RemoveFiltersRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_RemoveFilters_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ProcessLimbo::SetTransactionHeaderFor::RemoveFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::RemoveFiltersResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_RemoveFilters_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ProcessLimbo::SetTransactionHeaderFor::GetFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::GetFiltersRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_GetFilters_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ProcessLimbo::SetTransactionHeaderFor::GetFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::GetFiltersResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProcessLimbo_GetFilters_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace exception
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-exception/gen/llcpp/include/fuchsia/exception/llcpp/fidl.h b/zircon/system/fidl/fuchsia-exception/gen/llcpp/include/fuchsia/exception/llcpp/fidl.h
new file mode 100644
index 0000000..d10f5a9
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-exception/gen/llcpp/include/fuchsia/exception/llcpp/fidl.h
@@ -0,0 +1,2336 @@
+// 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/exception.h>
+#include <lib/zx/process.h>
+#include <lib/zx/thread.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace exception {
+
+struct ProcessLimbo_RemoveFilters_Response;
+struct ProcessLimbo_RemoveFilters_Result;
+struct ProcessLimbo_ReleaseProcess_Response;
+struct ProcessLimbo_ReleaseProcess_Result;
+struct ProcessLimbo_AppendFilters_Response;
+struct ProcessLimbo_AppendFilters_Result;
+enum class ExceptionType : uint32_t {
+ GENERAL = 8u,
+ FATAL_PAGE_FAULT = 264u,
+ UNDEFINED_INSTRUCTION = 520u,
+ SW_BREAKPOINT = 776u,
+ HW_BREAKPOINT = 1032u,
+ UNALIGNED_ACCESS = 1288u,
+ THREAD_STARTING = 32776u,
+ THREAD_EXITING = 33032u,
+ POLICY_ERROR = 33288u,
+ PROCESS_STARTING = 33544u,
+};
+
+
+struct ExceptionInfo;
+class Handler;
+struct ProcessExceptionMetadata;
+struct ProcessLimbo_WatchProcessesWaitingOnException_Response;
+struct ProcessLimbo_WatchProcessesWaitingOnException_Result;
+struct ProcessException;
+struct ProcessLimbo_RetrieveException_Response;
+struct ProcessLimbo_RetrieveException_Result;
+class ProcessLimbo;
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_RemoveFilters_ResultTable;
+
+struct ProcessLimbo_RemoveFilters_Result {
+ ProcessLimbo_RemoveFilters_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static ProcessLimbo_RemoveFilters_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response* val) {
+ ProcessLimbo_RemoveFilters_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static ProcessLimbo_RemoveFilters_Result WithErr(int32_t* val) {
+ ProcessLimbo_RemoveFilters_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_RemoveFilters_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_ReleaseProcess_ResultTable;
+
+struct ProcessLimbo_ReleaseProcess_Result {
+ ProcessLimbo_ReleaseProcess_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static ProcessLimbo_ReleaseProcess_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response* val) {
+ ProcessLimbo_ReleaseProcess_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static ProcessLimbo_ReleaseProcess_Result WithErr(int32_t* val) {
+ ProcessLimbo_ReleaseProcess_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_ReleaseProcess_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_AppendFilters_ResultTable;
+
+struct ProcessLimbo_AppendFilters_Result {
+ ProcessLimbo_AppendFilters_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static ProcessLimbo_AppendFilters_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response* val) {
+ ProcessLimbo_AppendFilters_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static ProcessLimbo_AppendFilters_Result WithErr(int32_t* val) {
+ ProcessLimbo_AppendFilters_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_AppendFilters_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessExceptionMetadataTable;
+
+// Intended to be read only metadada associated with an exception waiting in
+// limbo. The handles provided will only have read-only access to the resource,
+// so no modification can be done to them.
+//
+// NOTE: Both |process| and |thread| will be valid if present.
+struct ProcessExceptionMetadata final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const ::llcpp::fuchsia::exception::ExceptionInfo& info() const {
+ ZX_ASSERT(has_info());
+ return *reinterpret_cast<const ::llcpp::fuchsia::exception::ExceptionInfo*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::exception::ExceptionInfo& info() {
+ ZX_ASSERT(has_info());
+ return *reinterpret_cast<::llcpp::fuchsia::exception::ExceptionInfo*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_info() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Only has ZX_RIGHT_READ and ZX_RIGHT_GET_PROPERTY rights.
+ const ::zx::process& process() const {
+ ZX_ASSERT(has_process());
+ return *reinterpret_cast<const ::zx::process*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::zx::process& process() {
+ ZX_ASSERT(has_process());
+ return *reinterpret_cast<::zx::process*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_process() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // The thread that generated the exception.
+ // The process may have other threads that are not reflected here.
+ // Only has ZX_RIGHT_READ and ZX_RIGHT_GET_PROPERTY rights.
+ const ::zx::thread& thread() const {
+ ZX_ASSERT(has_thread());
+ return *reinterpret_cast<const ::zx::thread*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::zx::thread& thread() {
+ ZX_ASSERT(has_thread());
+ return *reinterpret_cast<::zx::thread*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_thread() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ ProcessExceptionMetadata() = default;
+ ~ProcessExceptionMetadata() = default;
+ ProcessExceptionMetadata(ProcessExceptionMetadata&& other) noexcept = default;
+ ProcessExceptionMetadata& operator=(ProcessExceptionMetadata&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessExceptionMetadataTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 88;
+ static constexpr bool HasPointer = true;
+
+ private:
+ ProcessExceptionMetadata(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class ProcessExceptionMetadata::Builder {
+ public:
+ ProcessExceptionMetadata view() { return ProcessExceptionMetadata(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_info(::llcpp::fuchsia::exception::ExceptionInfo* elem);
+
+ // Only has ZX_RIGHT_READ and ZX_RIGHT_GET_PROPERTY rights.
+ Builder&& set_process(::zx::process* elem);
+
+ // The thread that generated the exception.
+ // The process may have other threads that are not reflected here.
+ // Only has ZX_RIGHT_READ and ZX_RIGHT_GET_PROPERTY rights.
+ Builder&& set_thread(::zx::thread* elem);
+
+ private:
+ Builder() = default;
+ friend Builder ProcessExceptionMetadata::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 3> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_WatchProcessesWaitingOnException_ResultTable;
+
+struct ProcessLimbo_WatchProcessesWaitingOnException_Result {
+ ProcessLimbo_WatchProcessesWaitingOnException_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static ProcessLimbo_WatchProcessesWaitingOnException_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response* val) {
+ ProcessLimbo_WatchProcessesWaitingOnException_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static ProcessLimbo_WatchProcessesWaitingOnException_Result WithErr(int32_t* val) {
+ ProcessLimbo_WatchProcessesWaitingOnException_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_WatchProcessesWaitingOnException_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 64;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 3344;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessExceptionTable;
+
+// Generic wrapper over a thread exception. Mirrors closely the information
+// given by an exception channel.
+struct ProcessException final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const ::zx::exception& exception() const {
+ ZX_ASSERT(has_exception());
+ return *reinterpret_cast<const ::zx::exception*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::zx::exception& exception() {
+ ZX_ASSERT(has_exception());
+ return *reinterpret_cast<::zx::exception*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_exception() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ const ::llcpp::fuchsia::exception::ExceptionInfo& info() const {
+ ZX_ASSERT(has_info());
+ return *reinterpret_cast<const ::llcpp::fuchsia::exception::ExceptionInfo*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::exception::ExceptionInfo& info() {
+ ZX_ASSERT(has_info());
+ return *reinterpret_cast<::llcpp::fuchsia::exception::ExceptionInfo*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_info() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ const ::zx::process& process() const {
+ ZX_ASSERT(has_process());
+ return *reinterpret_cast<const ::zx::process*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::zx::process& process() {
+ ZX_ASSERT(has_process());
+ return *reinterpret_cast<::zx::process*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_process() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ const ::zx::thread& thread() const {
+ ZX_ASSERT(has_thread());
+ return *reinterpret_cast<const ::zx::thread*>(EnvelopesView::at(4 - 1).data);
+ }
+ ::zx::thread& thread() {
+ ZX_ASSERT(has_thread());
+ return *reinterpret_cast<::zx::thread*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_thread() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ ProcessException() = default;
+ ~ProcessException() = default;
+ ProcessException(ProcessException&& other) noexcept = default;
+ ProcessException& operator=(ProcessException&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessExceptionTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 112;
+ static constexpr bool HasPointer = true;
+
+ private:
+ ProcessException(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class ProcessException::Builder {
+ public:
+ ProcessException view() { return ProcessException(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_exception(::zx::exception* elem);
+
+ Builder&& set_info(::llcpp::fuchsia::exception::ExceptionInfo* elem);
+
+ Builder&& set_process(::zx::process* elem);
+
+ Builder&& set_thread(::zx::thread* elem);
+
+ private:
+ Builder() = default;
+ friend Builder ProcessException::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 4> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_RetrieveException_ResultTable;
+
+struct ProcessLimbo_RetrieveException_Result {
+ ProcessLimbo_RetrieveException_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static ProcessLimbo_RetrieveException_Result WithResponse(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response* val) {
+ ProcessLimbo_RetrieveException_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static ProcessLimbo_RetrieveException_Result WithErr(int32_t* val) {
+ ProcessLimbo_RetrieveException_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_RetrieveException_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 128;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_RemoveFilters_ResponseTable;
+
+struct ProcessLimbo_RemoveFilters_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_RemoveFilters_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_ReleaseProcess_ResponseTable;
+
+struct ProcessLimbo_ReleaseProcess_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_ReleaseProcess_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_AppendFilters_ResponseTable;
+
+struct ProcessLimbo_AppendFilters_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_AppendFilters_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+constexpr uint64_t MAX_FILTER_LENGTH = 32u;
+
+constexpr uint64_t MAX_FILTERS_PER_CALL = 32u;
+
+// The maximum amount of exceptions that will be listed at any given time by a
+// call to |ListProcessesWaitingOnException|.
+constexpr uint64_t MAX_EXCEPTIONS_PER_CALL = 32u;
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ExceptionInfoTable;
+
+// Basic exception information associated with a particular exception.
+// Maps to `zx_exception_info_t`.
+struct ExceptionInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ExceptionInfoTable;
+ 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 process_koid = {};
+
+ uint64_t thread_koid = {};
+
+ ::llcpp::fuchsia::exception::ExceptionType type = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_HandlerOnExceptionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_HandlerOnExceptionResponseTable;
+
+// Protocol meant for clients interested in handling exceptions for a
+// particular service.
+class Handler final {
+ Handler() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.exception.Handler";
+
+ using OnExceptionResponse = ::fidl::AnyZeroArgMessage;
+ struct OnExceptionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::exception exception;
+ ::llcpp::fuchsia::exception::ExceptionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_HandlerOnExceptionRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class OnException_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ OnException_Impl(::zx::unowned_channel _client_end, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info);
+ ~OnException_Impl() = default;
+ OnException_Impl(OnException_Impl&& other) = default;
+ OnException_Impl& operator=(OnException_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 OnException = OnException_Impl<OnExceptionResponse>;
+ };
+
+ // 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 OnException_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ OnException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::fidl::BytePart _response_buffer);
+ ~OnException_Impl() = default;
+ OnException_Impl(OnException_Impl&& other) = default;
+ OnException_Impl& operator=(OnException_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 OnException = OnException_Impl<OnExceptionResponse>;
+ };
+
+ 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_; }
+
+ // This exception mirrors closely the information provided by exception
+ // channels. The design is to have clients of this API behave as closely as
+ // possible to native exception handlers that are listening to an exception
+ // channel.
+ //
+ // `exception` is an exception handle, which controls the exception's
+ // lifetime. See exception zircon docs for more information.
+ //
+ // `info` represents basic exception information as provided by the
+ // exception channel.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::OnException OnException(::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info);
+
+ // This exception mirrors closely the information provided by exception
+ // channels. The design is to have clients of this API behave as closely as
+ // possible to native exception handlers that are listening to an exception
+ // channel.
+ //
+ // `exception` is an exception handle, which controls the exception's
+ // lifetime. See exception zircon docs for more information.
+ //
+ // `info` represents basic exception information as provided by the
+ // exception channel.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OnException OnException(::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::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:
+
+ // This exception mirrors closely the information provided by exception
+ // channels. The design is to have clients of this API behave as closely as
+ // possible to native exception handlers that are listening to an exception
+ // channel.
+ //
+ // `exception` is an exception handle, which controls the exception's
+ // lifetime. See exception zircon docs for more information.
+ //
+ // `info` represents basic exception information as provided by the
+ // exception channel.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::OnException OnException(::zx::unowned_channel _client_end, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info);
+
+ // This exception mirrors closely the information provided by exception
+ // channels. The design is to have clients of this API behave as closely as
+ // possible to native exception handlers that are listening to an exception
+ // channel.
+ //
+ // `exception` is an exception handle, which controls the exception's
+ // lifetime. See exception zircon docs for more information.
+ //
+ // `info` represents basic exception information as provided by the
+ // exception channel.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OnException OnException(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, ::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:
+
+ // This exception mirrors closely the information provided by exception
+ // channels. The design is to have clients of this API behave as closely as
+ // possible to native exception handlers that are listening to an exception
+ // channel.
+ //
+ // `exception` is an exception handle, which controls the exception's
+ // lifetime. See exception zircon docs for more information.
+ //
+ // `info` represents basic exception information as provided by the
+ // exception channel.
+ static ::fidl::DecodeResult<OnExceptionResponse> OnException(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnExceptionRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Handler;
+ using _Base = ::fidl::CompleterBase;
+
+ class OnExceptionCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using OnExceptionCompleter = ::fidl::Completer<OnExceptionCompleterBase>;
+
+ virtual void OnException(::zx::exception exception, ::llcpp::fuchsia::exception::ExceptionInfo info, OnExceptionCompleter::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 OnExceptionRequest(const ::fidl::DecodedMessage<Handler::OnExceptionRequest>& _msg);
+ static void OnExceptionResponse(const ::fidl::DecodedMessage<Handler::OnExceptionResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_WatchProcessesWaitingOnException_ResponseTable;
+
+struct ProcessLimbo_WatchProcessesWaitingOnException_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_WatchProcessesWaitingOnException_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 64;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 3328;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimbo_RetrieveException_ResponseTable;
+
+struct ProcessLimbo_RetrieveException_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimbo_RetrieveException_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 112;
+ static constexpr bool HasPointer = true;
+
+ ::llcpp::fuchsia::exception::ProcessException process_exception = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboSetActiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboSetActiveResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchActiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchActiveResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRetrieveExceptionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRetrieveExceptionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboReleaseProcessRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboReleaseProcessResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboAppendFiltersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboAppendFiltersResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRemoveFiltersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboRemoveFiltersResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboGetFiltersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_exception_ProcessLimboGetFiltersResponseTable;
+
+// Protocol meant for clients interested in obtaining processes that are
+// suspended waiting for an exception handler (in limbo). This is the core
+// feature that enables Just In Time (JIT) debugging.
+//
+// An example usage of this API would be having a debugger listen on limbo for
+// new processes. Then another component (eg. a CLI tool) could activate the
+// limbo, meaning that the system is now ready to capture crashing processes.
+// As the debugger got a notification that the limbo is now active, it can
+// correctly handle newly excepted processes and do its normal workflow.
+class ProcessLimbo final {
+ ProcessLimbo() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.exception.ProcessLimbo";
+
+ using SetActiveResponse = ::fidl::AnyZeroArgMessage;
+ struct SetActiveRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool active;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboSetActiveRequestTable;
+ 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;
+ };
+
+ struct WatchActiveResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool is_active;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboWatchActiveResponseTable;
+ 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 WatchActiveRequest = ::fidl::AnyZeroArgMessage;
+
+ struct WatchProcessesWaitingOnExceptionResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboWatchProcessesWaitingOnExceptionResponseTable;
+ static constexpr uint32_t MaxNumHandles = 64;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 3344;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using WatchProcessesWaitingOnExceptionRequest = ::fidl::AnyZeroArgMessage;
+
+ struct RetrieveExceptionResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboRetrieveExceptionResponseTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 128;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RetrieveExceptionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t process_koid;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboRetrieveExceptionRequestTable;
+ 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 = RetrieveExceptionResponse;
+ };
+
+ struct ReleaseProcessResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboReleaseProcessResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ReleaseProcessRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t process_koid;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboReleaseProcessRequestTable;
+ 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 = ReleaseProcessResponse;
+ };
+
+ struct AppendFiltersResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboAppendFiltersResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AppendFiltersRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::fidl::StringView> filters;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboAppendFiltersRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1536;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1536;
+ 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 = AppendFiltersResponse;
+ };
+
+ struct RemoveFiltersResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboRemoveFiltersResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RemoveFiltersRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::fidl::StringView> filters;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboRemoveFiltersRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1536;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1536;
+ 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 = RemoveFiltersResponse;
+ };
+
+ struct GetFiltersResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::fidl::StringView> filters;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_exception_ProcessLimboGetFiltersResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1536;
+ 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 GetFiltersRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class SetActive_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetActive_Impl(::zx::unowned_channel _client_end, bool active);
+ ~SetActive_Impl() = default;
+ SetActive_Impl(SetActive_Impl&& other) = default;
+ SetActive_Impl& operator=(SetActive_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 WatchActive_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WatchActive_Impl(::zx::unowned_channel _client_end);
+ ~WatchActive_Impl() = default;
+ WatchActive_Impl(WatchActive_Impl&& other) = default;
+ WatchActive_Impl& operator=(WatchActive_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 WatchProcessesWaitingOnException_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WatchProcessesWaitingOnException_Impl(::zx::unowned_channel _client_end);
+ ~WatchProcessesWaitingOnException_Impl() = default;
+ WatchProcessesWaitingOnException_Impl(WatchProcessesWaitingOnException_Impl&& other) = default;
+ WatchProcessesWaitingOnException_Impl& operator=(WatchProcessesWaitingOnException_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 RetrieveException_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RetrieveException_Impl(::zx::unowned_channel _client_end, uint64_t process_koid);
+ ~RetrieveException_Impl() = default;
+ RetrieveException_Impl(RetrieveException_Impl&& other) = default;
+ RetrieveException_Impl& operator=(RetrieveException_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 ReleaseProcess_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReleaseProcess_Impl(::zx::unowned_channel _client_end, uint64_t process_koid);
+ ~ReleaseProcess_Impl() = default;
+ ReleaseProcess_Impl(ReleaseProcess_Impl&& other) = default;
+ ReleaseProcess_Impl& operator=(ReleaseProcess_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 AppendFilters_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AppendFilters_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters);
+ ~AppendFilters_Impl() = default;
+ AppendFilters_Impl(AppendFilters_Impl&& other) = default;
+ AppendFilters_Impl& operator=(AppendFilters_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 RemoveFilters_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RemoveFilters_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters);
+ ~RemoveFilters_Impl() = default;
+ RemoveFilters_Impl(RemoveFilters_Impl&& other) = default;
+ RemoveFilters_Impl& operator=(RemoveFilters_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 GetFilters_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetFilters_Impl(::zx::unowned_channel _client_end);
+ ~GetFilters_Impl() = default;
+ GetFilters_Impl(GetFilters_Impl&& other) = default;
+ GetFilters_Impl& operator=(GetFilters_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 SetActive = SetActive_Impl<SetActiveResponse>;
+ using WatchActive = WatchActive_Impl<WatchActiveResponse>;
+ using WatchProcessesWaitingOnException = WatchProcessesWaitingOnException_Impl<WatchProcessesWaitingOnExceptionResponse>;
+ using RetrieveException = RetrieveException_Impl<RetrieveExceptionResponse>;
+ using ReleaseProcess = ReleaseProcess_Impl<ReleaseProcessResponse>;
+ using AppendFilters = AppendFilters_Impl<AppendFiltersResponse>;
+ using RemoveFilters = RemoveFilters_Impl<RemoveFiltersResponse>;
+ using GetFilters = GetFilters_Impl<GetFiltersResponse>;
+ };
+
+ // 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 SetActive_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer);
+ ~SetActive_Impl() = default;
+ SetActive_Impl(SetActive_Impl&& other) = default;
+ SetActive_Impl& operator=(SetActive_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 WatchActive_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WatchActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WatchActive_Impl() = default;
+ WatchActive_Impl(WatchActive_Impl&& other) = default;
+ WatchActive_Impl& operator=(WatchActive_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 WatchProcessesWaitingOnException_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WatchProcessesWaitingOnException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WatchProcessesWaitingOnException_Impl() = default;
+ WatchProcessesWaitingOnException_Impl(WatchProcessesWaitingOnException_Impl&& other) = default;
+ WatchProcessesWaitingOnException_Impl& operator=(WatchProcessesWaitingOnException_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 RetrieveException_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RetrieveException_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer);
+ ~RetrieveException_Impl() = default;
+ RetrieveException_Impl(RetrieveException_Impl&& other) = default;
+ RetrieveException_Impl& operator=(RetrieveException_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 ReleaseProcess_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReleaseProcess_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer);
+ ~ReleaseProcess_Impl() = default;
+ ReleaseProcess_Impl(ReleaseProcess_Impl&& other) = default;
+ ReleaseProcess_Impl& operator=(ReleaseProcess_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 AppendFilters_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AppendFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer);
+ ~AppendFilters_Impl() = default;
+ AppendFilters_Impl(AppendFilters_Impl&& other) = default;
+ AppendFilters_Impl& operator=(AppendFilters_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 RemoveFilters_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RemoveFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer);
+ ~RemoveFilters_Impl() = default;
+ RemoveFilters_Impl(RemoveFilters_Impl&& other) = default;
+ RemoveFilters_Impl& operator=(RemoveFilters_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 GetFilters_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetFilters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetFilters_Impl() = default;
+ GetFilters_Impl(GetFilters_Impl&& other) = default;
+ GetFilters_Impl& operator=(GetFilters_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 SetActive = SetActive_Impl<SetActiveResponse>;
+ using WatchActive = WatchActive_Impl<WatchActiveResponse>;
+ using WatchProcessesWaitingOnException = WatchProcessesWaitingOnException_Impl<WatchProcessesWaitingOnExceptionResponse>;
+ using RetrieveException = RetrieveException_Impl<RetrieveExceptionResponse>;
+ using ReleaseProcess = ReleaseProcess_Impl<ReleaseProcessResponse>;
+ using AppendFilters = AppendFilters_Impl<AppendFiltersResponse>;
+ using RemoveFilters = RemoveFilters_Impl<RemoveFiltersResponse>;
+ using GetFilters = GetFilters_Impl<GetFiltersResponse>;
+ };
+
+ 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_; }
+
+ // Set the active state of the limbo. Will trigger the |WatchActive| event
+ // if there was a change, meaning that any listening components will receive
+ // a notification. This includes the caller of |SetActive|.
+ //
+ // When a limbo is inactive, there will not be any processes waiting on it,
+ // meaning that any waiting processes will be freed upon deactivating the
+ // limbo.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetActive SetActive(bool active);
+
+ // Set the active state of the limbo. Will trigger the |WatchActive| event
+ // if there was a change, meaning that any listening components will receive
+ // a notification. This includes the caller of |SetActive|.
+ //
+ // When a limbo is inactive, there will not be any processes waiting on it,
+ // meaning that any waiting processes will be freed upon deactivating the
+ // limbo.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetActive SetActive(::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer);
+
+ // Watchs for changes determining whether the limbo is currently active,
+ // using a Hanging Get pattern. An active limbo could be empty (not have
+ // any processes waiting on an exception).
+ // When a limbo is inactive, there will not be any processes waiting on it.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WatchActive WatchActive();
+
+ // Watchs for changes determining whether the limbo is currently active,
+ // using a Hanging Get pattern. An active limbo could be empty (not have
+ // any processes waiting on an exception).
+ // When a limbo is inactive, there will not be any processes waiting on it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WatchActive WatchActive(::fidl::BytePart _response_buffer);
+
+ // Watch for processes that are waiting on exceptions, using a Hanging Get
+ // Pattern.
+ //
+ // Returns information on all the processes currently waiting on an exception.
+ // The information provided is intended to correctly identify an exception
+ // and determine whether the caller wants to actually handle it.
+ // To retrieve an exception, use the |GetException| call.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo
+ // becomes inactive.
+ //
+ // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ
+ // right, so no modification will be able to be done on them.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::WatchProcessesWaitingOnException WatchProcessesWaitingOnException();
+
+ // Watch for processes that are waiting on exceptions, using a Hanging Get
+ // Pattern.
+ //
+ // Returns information on all the processes currently waiting on an exception.
+ // The information provided is intended to correctly identify an exception
+ // and determine whether the caller wants to actually handle it.
+ // To retrieve an exception, use the |GetException| call.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo
+ // becomes inactive.
+ //
+ // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ
+ // right, so no modification will be able to be done on them.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WatchProcessesWaitingOnException WatchProcessesWaitingOnException(::fidl::BytePart _response_buffer);
+
+ // Removes the process from limbo and retrieves the exception handle and
+ // associated metadata from an exception.
+ //
+ // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the
+ // list of available exceptions.
+ //
+ // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception.
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::RetrieveException RetrieveException(uint64_t process_koid);
+
+ // Removes the process from limbo and retrieves the exception handle and
+ // associated metadata from an exception.
+ //
+ // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the
+ // list of available exceptions.
+ //
+ // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception.
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RetrieveException RetrieveException(::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer);
+
+ // Removes the process from limbo, releasing the exception. This will make
+ // it "bubble up" beyond the scope of of this limbo, making it
+ // unretrievable in the future from here.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReleaseProcess ReleaseProcess(uint64_t process_koid);
+
+ // Removes the process from limbo, releasing the exception. This will make
+ // it "bubble up" beyond the scope of of this limbo, making it
+ // unretrievable in the future from here.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReleaseProcess ReleaseProcess(::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer);
+
+ // Adds filters to the limbo. Filters determine what processes the limbo
+ // will store when receiving an exception. Repeated filters will be
+ // ignored. Filters work by "filtering out" processes. It means that if a
+ // filter matches, that process won't get included.
+ //
+ // Filters work by substring matching. This means that a process name has
+ // to have the filter as a substring in order to match it. Example:
+ //
+ // Filter = "dev".
+ // Process = "process" won't match.
+ // Process = "devcoordinator" will match.
+ //
+ // Adding filters is transactional: either all of them go in, or none at
+ // all. The maximum amount of filters is determined by
+ // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES
+ // is returned.
+ //
+ // Changing filters have no effect on processes that are currently waiting
+ // on an exception, but rather which future processes that will remain in
+ // the limbo.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::AppendFilters AppendFilters(::fidl::VectorView<::fidl::StringView> filters);
+
+ // Adds filters to the limbo. Filters determine what processes the limbo
+ // will store when receiving an exception. Repeated filters will be
+ // ignored. Filters work by "filtering out" processes. It means that if a
+ // filter matches, that process won't get included.
+ //
+ // Filters work by substring matching. This means that a process name has
+ // to have the filter as a substring in order to match it. Example:
+ //
+ // Filter = "dev".
+ // Process = "process" won't match.
+ // Process = "devcoordinator" will match.
+ //
+ // Adding filters is transactional: either all of them go in, or none at
+ // all. The maximum amount of filters is determined by
+ // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES
+ // is returned.
+ //
+ // Changing filters have no effect on processes that are currently waiting
+ // on an exception, but rather which future processes that will remain in
+ // the limbo.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AppendFilters AppendFilters(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer);
+
+ // Removes filters to the limbo. Any filters that are not currently present
+ // on the limbo will be ignored.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::RemoveFilters RemoveFilters(::fidl::VectorView<::fidl::StringView> filters);
+
+ // Removes filters to the limbo. Any filters that are not currently present
+ // on the limbo will be ignored.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RemoveFilters RemoveFilters(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer);
+
+ // Returns filters that are currently active within the limbo. If the limbo
+ // is inactive, it will return an empty vector.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetFilters GetFilters();
+
+ // Returns filters that are currently active within the limbo. If the limbo
+ // is inactive, it will return an empty vector.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetFilters GetFilters(::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:
+
+ // Set the active state of the limbo. Will trigger the |WatchActive| event
+ // if there was a change, meaning that any listening components will receive
+ // a notification. This includes the caller of |SetActive|.
+ //
+ // When a limbo is inactive, there will not be any processes waiting on it,
+ // meaning that any waiting processes will be freed upon deactivating the
+ // limbo.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetActive SetActive(::zx::unowned_channel _client_end, bool active);
+
+ // Set the active state of the limbo. Will trigger the |WatchActive| event
+ // if there was a change, meaning that any listening components will receive
+ // a notification. This includes the caller of |SetActive|.
+ //
+ // When a limbo is inactive, there will not be any processes waiting on it,
+ // meaning that any waiting processes will be freed upon deactivating the
+ // limbo.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetActive SetActive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool active, ::fidl::BytePart _response_buffer);
+
+ // Watchs for changes determining whether the limbo is currently active,
+ // using a Hanging Get pattern. An active limbo could be empty (not have
+ // any processes waiting on an exception).
+ // When a limbo is inactive, there will not be any processes waiting on it.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WatchActive WatchActive(::zx::unowned_channel _client_end);
+
+ // Watchs for changes determining whether the limbo is currently active,
+ // using a Hanging Get pattern. An active limbo could be empty (not have
+ // any processes waiting on an exception).
+ // When a limbo is inactive, there will not be any processes waiting on it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WatchActive WatchActive(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Watch for processes that are waiting on exceptions, using a Hanging Get
+ // Pattern.
+ //
+ // Returns information on all the processes currently waiting on an exception.
+ // The information provided is intended to correctly identify an exception
+ // and determine whether the caller wants to actually handle it.
+ // To retrieve an exception, use the |GetException| call.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo
+ // becomes inactive.
+ //
+ // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ
+ // right, so no modification will be able to be done on them.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::WatchProcessesWaitingOnException WatchProcessesWaitingOnException(::zx::unowned_channel _client_end);
+
+ // Watch for processes that are waiting on exceptions, using a Hanging Get
+ // Pattern.
+ //
+ // Returns information on all the processes currently waiting on an exception.
+ // The information provided is intended to correctly identify an exception
+ // and determine whether the caller wants to actually handle it.
+ // To retrieve an exception, use the |GetException| call.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo
+ // becomes inactive.
+ //
+ // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ
+ // right, so no modification will be able to be done on them.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WatchProcessesWaitingOnException WatchProcessesWaitingOnException(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Removes the process from limbo and retrieves the exception handle and
+ // associated metadata from an exception.
+ //
+ // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the
+ // list of available exceptions.
+ //
+ // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception.
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::RetrieveException RetrieveException(::zx::unowned_channel _client_end, uint64_t process_koid);
+
+ // Removes the process from limbo and retrieves the exception handle and
+ // associated metadata from an exception.
+ //
+ // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the
+ // list of available exceptions.
+ //
+ // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception.
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RetrieveException RetrieveException(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer);
+
+ // Removes the process from limbo, releasing the exception. This will make
+ // it "bubble up" beyond the scope of of this limbo, making it
+ // unretrievable in the future from here.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReleaseProcess ReleaseProcess(::zx::unowned_channel _client_end, uint64_t process_koid);
+
+ // Removes the process from limbo, releasing the exception. This will make
+ // it "bubble up" beyond the scope of of this limbo, making it
+ // unretrievable in the future from here.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReleaseProcess ReleaseProcess(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t process_koid, ::fidl::BytePart _response_buffer);
+
+ // Adds filters to the limbo. Filters determine what processes the limbo
+ // will store when receiving an exception. Repeated filters will be
+ // ignored. Filters work by "filtering out" processes. It means that if a
+ // filter matches, that process won't get included.
+ //
+ // Filters work by substring matching. This means that a process name has
+ // to have the filter as a substring in order to match it. Example:
+ //
+ // Filter = "dev".
+ // Process = "process" won't match.
+ // Process = "devcoordinator" will match.
+ //
+ // Adding filters is transactional: either all of them go in, or none at
+ // all. The maximum amount of filters is determined by
+ // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES
+ // is returned.
+ //
+ // Changing filters have no effect on processes that are currently waiting
+ // on an exception, but rather which future processes that will remain in
+ // the limbo.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::AppendFilters AppendFilters(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters);
+
+ // Adds filters to the limbo. Filters determine what processes the limbo
+ // will store when receiving an exception. Repeated filters will be
+ // ignored. Filters work by "filtering out" processes. It means that if a
+ // filter matches, that process won't get included.
+ //
+ // Filters work by substring matching. This means that a process name has
+ // to have the filter as a substring in order to match it. Example:
+ //
+ // Filter = "dev".
+ // Process = "process" won't match.
+ // Process = "devcoordinator" will match.
+ //
+ // Adding filters is transactional: either all of them go in, or none at
+ // all. The maximum amount of filters is determined by
+ // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES
+ // is returned.
+ //
+ // Changing filters have no effect on processes that are currently waiting
+ // on an exception, but rather which future processes that will remain in
+ // the limbo.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AppendFilters AppendFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer);
+
+ // Removes filters to the limbo. Any filters that are not currently present
+ // on the limbo will be ignored.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::RemoveFilters RemoveFilters(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::StringView> filters);
+
+ // Removes filters to the limbo. Any filters that are not currently present
+ // on the limbo will be ignored.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RemoveFilters RemoveFilters(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::StringView> filters, ::fidl::BytePart _response_buffer);
+
+ // Returns filters that are currently active within the limbo. If the limbo
+ // is inactive, it will return an empty vector.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetFilters GetFilters(::zx::unowned_channel _client_end);
+
+ // Returns filters that are currently active within the limbo. If the limbo
+ // is inactive, it will return an empty vector.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetFilters GetFilters(::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:
+
+ // Set the active state of the limbo. Will trigger the |WatchActive| event
+ // if there was a change, meaning that any listening components will receive
+ // a notification. This includes the caller of |SetActive|.
+ //
+ // When a limbo is inactive, there will not be any processes waiting on it,
+ // meaning that any waiting processes will be freed upon deactivating the
+ // limbo.
+ static ::fidl::DecodeResult<SetActiveResponse> SetActive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetActiveRequest> params, ::fidl::BytePart response_buffer);
+
+ // Watchs for changes determining whether the limbo is currently active,
+ // using a Hanging Get pattern. An active limbo could be empty (not have
+ // any processes waiting on an exception).
+ // When a limbo is inactive, there will not be any processes waiting on it.
+ static ::fidl::DecodeResult<WatchActiveResponse> WatchActive(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Watch for processes that are waiting on exceptions, using a Hanging Get
+ // Pattern.
+ //
+ // Returns information on all the processes currently waiting on an exception.
+ // The information provided is intended to correctly identify an exception
+ // and determine whether the caller wants to actually handle it.
+ // To retrieve an exception, use the |GetException| call.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ // Returns ZX_ERR_CANCELED if there was an outstanding call and the limbo
+ // becomes inactive.
+ //
+ // NOTE: The |process| and |thread| handle will only have the ZX_RIGHT_READ
+ // right, so no modification will be able to be done on them.
+ static ::fidl::DecodeResult<WatchProcessesWaitingOnExceptionResponse> WatchProcessesWaitingOnException(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Removes the process from limbo and retrieves the exception handle and
+ // associated metadata from an exception.
+ //
+ // Use |ListProcessesWaitingOnException| to choose a |process_koid| from the
+ // list of available exceptions.
+ //
+ // Returns ZX_ERR_NOT_FOUND if the process is not waiting on an exception.
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ static ::fidl::DecodeResult<RetrieveExceptionResponse> RetrieveException(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RetrieveExceptionRequest> params, ::fidl::BytePart response_buffer);
+
+ // Removes the process from limbo, releasing the exception. This will make
+ // it "bubble up" beyond the scope of of this limbo, making it
+ // unretrievable in the future from here.
+ static ::fidl::DecodeResult<ReleaseProcessResponse> ReleaseProcess(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseProcessRequest> params, ::fidl::BytePart response_buffer);
+
+ // Adds filters to the limbo. Filters determine what processes the limbo
+ // will store when receiving an exception. Repeated filters will be
+ // ignored. Filters work by "filtering out" processes. It means that if a
+ // filter matches, that process won't get included.
+ //
+ // Filters work by substring matching. This means that a process name has
+ // to have the filter as a substring in order to match it. Example:
+ //
+ // Filter = "dev".
+ // Process = "process" won't match.
+ // Process = "devcoordinator" will match.
+ //
+ // Adding filters is transactional: either all of them go in, or none at
+ // all. The maximum amount of filters is determined by
+ // |MAX_FILTERS_PER_CALL|. If the maximum is exceeded, ZX_ERR_NO_RESOURCES
+ // is returned.
+ //
+ // Changing filters have no effect on processes that are currently waiting
+ // on an exception, but rather which future processes that will remain in
+ // the limbo.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ static ::fidl::DecodeResult<AppendFiltersResponse> AppendFilters(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AppendFiltersRequest> params, ::fidl::BytePart response_buffer);
+
+ // Removes filters to the limbo. Any filters that are not currently present
+ // on the limbo will be ignored.
+ //
+ // Returns ZX_ERR_UNAVAILABLE if limbo is not active.
+ static ::fidl::DecodeResult<RemoveFiltersResponse> RemoveFilters(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RemoveFiltersRequest> params, ::fidl::BytePart response_buffer);
+
+ // Returns filters that are currently active within the limbo. If the limbo
+ // is inactive, it will return an empty vector.
+ static ::fidl::DecodeResult<GetFiltersResponse> GetFilters(::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 = ProcessLimbo;
+ using _Base = ::fidl::CompleterBase;
+
+ class SetActiveCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetActiveCompleter = ::fidl::Completer<SetActiveCompleterBase>;
+
+ virtual void SetActive(bool active, SetActiveCompleter::Sync _completer) = 0;
+
+ class WatchActiveCompleterBase : public _Base {
+ public:
+ void Reply(bool is_active);
+ void Reply(::fidl::BytePart _buffer, bool is_active);
+ void Reply(::fidl::DecodedMessage<WatchActiveResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchActiveCompleter = ::fidl::Completer<WatchActiveCompleterBase>;
+
+ virtual void WatchActive(WatchActiveCompleter::Sync _completer) = 0;
+
+ class WatchProcessesWaitingOnExceptionCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result);
+ void ReplySuccess(::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::exception::ProcessExceptionMetadata> exception_list);
+ void Reply(::fidl::DecodedMessage<WatchProcessesWaitingOnExceptionResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchProcessesWaitingOnExceptionCompleter = ::fidl::Completer<WatchProcessesWaitingOnExceptionCompleterBase>;
+
+ virtual void WatchProcessesWaitingOnException(WatchProcessesWaitingOnExceptionCompleter::Sync _completer) = 0;
+
+ class RetrieveExceptionCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result);
+ void ReplySuccess(::llcpp::fuchsia::exception::ProcessException process_exception);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessException process_exception);
+ void Reply(::fidl::DecodedMessage<RetrieveExceptionResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RetrieveExceptionCompleter = ::fidl::Completer<RetrieveExceptionCompleterBase>;
+
+ virtual void RetrieveException(uint64_t process_koid, RetrieveExceptionCompleter::Sync _completer) = 0;
+
+ class ReleaseProcessCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ReleaseProcessResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReleaseProcessCompleter = ::fidl::Completer<ReleaseProcessCompleterBase>;
+
+ virtual void ReleaseProcess(uint64_t process_koid, ReleaseProcessCompleter::Sync _completer) = 0;
+
+ class AppendFiltersCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<AppendFiltersResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AppendFiltersCompleter = ::fidl::Completer<AppendFiltersCompleterBase>;
+
+ virtual void AppendFilters(::fidl::VectorView<::fidl::StringView> filters, AppendFiltersCompleter::Sync _completer) = 0;
+
+ class RemoveFiltersCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<RemoveFiltersResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RemoveFiltersCompleter = ::fidl::Completer<RemoveFiltersCompleterBase>;
+
+ virtual void RemoveFilters(::fidl::VectorView<::fidl::StringView> filters, RemoveFiltersCompleter::Sync _completer) = 0;
+
+ class GetFiltersCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::fidl::StringView> filters);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::fidl::StringView> filters);
+ void Reply(::fidl::DecodedMessage<GetFiltersResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetFiltersCompleter = ::fidl::Completer<GetFiltersCompleterBase>;
+
+ virtual void GetFilters(GetFiltersCompleter::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 SetActiveRequest(const ::fidl::DecodedMessage<ProcessLimbo::SetActiveRequest>& _msg);
+ static void SetActiveResponse(const ::fidl::DecodedMessage<ProcessLimbo::SetActiveResponse>& _msg);
+ static void WatchActiveRequest(const ::fidl::DecodedMessage<ProcessLimbo::WatchActiveRequest>& _msg);
+ static void WatchActiveResponse(const ::fidl::DecodedMessage<ProcessLimbo::WatchActiveResponse>& _msg);
+ static void WatchProcessesWaitingOnExceptionRequest(const ::fidl::DecodedMessage<ProcessLimbo::WatchProcessesWaitingOnExceptionRequest>& _msg);
+ static void WatchProcessesWaitingOnExceptionResponse(const ::fidl::DecodedMessage<ProcessLimbo::WatchProcessesWaitingOnExceptionResponse>& _msg);
+ static void RetrieveExceptionRequest(const ::fidl::DecodedMessage<ProcessLimbo::RetrieveExceptionRequest>& _msg);
+ static void RetrieveExceptionResponse(const ::fidl::DecodedMessage<ProcessLimbo::RetrieveExceptionResponse>& _msg);
+ static void ReleaseProcessRequest(const ::fidl::DecodedMessage<ProcessLimbo::ReleaseProcessRequest>& _msg);
+ static void ReleaseProcessResponse(const ::fidl::DecodedMessage<ProcessLimbo::ReleaseProcessResponse>& _msg);
+ static void AppendFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::AppendFiltersRequest>& _msg);
+ static void AppendFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::AppendFiltersResponse>& _msg);
+ static void RemoveFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::RemoveFiltersRequest>& _msg);
+ static void RemoveFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::RemoveFiltersResponse>& _msg);
+ static void GetFiltersRequest(const ::fidl::DecodedMessage<ProcessLimbo::GetFiltersRequest>& _msg);
+ static void GetFiltersResponse(const ::fidl::DecodedMessage<ProcessLimbo::GetFiltersResponse>& _msg);
+ };
+};
+
+} // namespace exception
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response>);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_RemoveFilters_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response>);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_ReleaseProcess_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response>);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_AppendFilters_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ExceptionInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ExceptionInfo>);
+static_assert(offsetof(::llcpp::fuchsia::exception::ExceptionInfo, process_koid) == 0);
+static_assert(offsetof(::llcpp::fuchsia::exception::ExceptionInfo, thread_koid) == 8);
+static_assert(offsetof(::llcpp::fuchsia::exception::ExceptionInfo, type) == 16);
+static_assert(sizeof(::llcpp::fuchsia::exception::ExceptionInfo) == ::llcpp::fuchsia::exception::ExceptionInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::Handler::OnExceptionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::Handler::OnExceptionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::Handler::OnExceptionRequest)
+ == ::llcpp::fuchsia::exception::Handler::OnExceptionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::Handler::OnExceptionRequest, exception) == 16);
+static_assert(offsetof(::llcpp::fuchsia::exception::Handler::OnExceptionRequest, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessExceptionMetadata> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessExceptionMetadata>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response>);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response, exception_list) == 0);
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_WatchProcessesWaitingOnException_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessException> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessException>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response>);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response, process_exception) == 0);
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response) == ::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::exception::ProcessLimbo_RetrieveException_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::SetActiveRequest, active) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::WatchActiveResponse, is_active) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::WatchProcessesWaitingOnExceptionResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionRequest, process_koid) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::RetrieveExceptionResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessRequest, process_koid) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::ReleaseProcessResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersRequest, filters) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::AppendFiltersResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersRequest, filters) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::RemoveFiltersResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse)
+ == ::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::exception::ProcessLimbo::GetFiltersResponse, filters) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-fs/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-fs/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..8b67ee8
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-fs/gen/llcpp/fidl.cc
@@ -0,0 +1,552 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/fs/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace fs {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kAdmin_Shutdown_Ordinal = 0x2496c0000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kAdmin_Shutdown_GenOrdinal = 0x5476abc45167ca8elu;
+extern "C" const fidl_type_t v1_fuchsia_fs_AdminShutdownRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fs_AdminShutdownResponseTable;
+
+} // namespace
+template <>
+Admin::ResultOf::Shutdown_Impl<Admin::ShutdownResponse>::Shutdown_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShutdownRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ShutdownRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShutdownRequest));
+ ::fidl::DecodedMessage<ShutdownRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Admin::InPlace::Shutdown(std::move(_client_end), Super::response_buffer()));
+}
+
+Admin::ResultOf::Shutdown Admin::SyncClient::Shutdown() {
+ return ResultOf::Shutdown(::zx::unowned_channel(this->channel_));
+}
+
+Admin::ResultOf::Shutdown Admin::Call::Shutdown(::zx::unowned_channel _client_end) {
+ return ResultOf::Shutdown(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Admin::ShutdownResponse> Admin::InPlace::Shutdown(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ShutdownRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ShutdownRequest> params(std::move(_request_buffer));
+ Admin::SetTransactionHeaderFor::ShutdownRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Admin::ShutdownResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ShutdownRequest, ShutdownResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Admin::ShutdownResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Admin::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kAdmin_Shutdown_Ordinal:
+ case kAdmin_Shutdown_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ShutdownRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Shutdown(
+ Interface::ShutdownCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Admin::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Admin::Interface::ShutdownCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShutdownResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ShutdownResponse*>(_write_bytes);
+ Admin::SetTransactionHeaderFor::ShutdownResponse(
+ ::fidl::DecodedMessage<ShutdownResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ShutdownResponse::PrimarySize,
+ ShutdownResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShutdownResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ShutdownResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Admin::SetTransactionHeaderFor::ShutdownRequest(const ::fidl::DecodedMessage<Admin::ShutdownRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAdmin_Shutdown_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Admin::SetTransactionHeaderFor::ShutdownResponse(const ::fidl::DecodedMessage<Admin::ShutdownResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAdmin_Shutdown_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+::llcpp::fuchsia::fs::FilesystemInfo::Builder FilesystemInfo::Build() {
+ return FilesystemInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_total_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_used_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_total_nodes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_used_nodes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_free_shared_pool_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_fs_id(::zx::event* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[6 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 6) {
+ max_ordinal_ = 6;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_block_size(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[7 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 7) {
+ max_ordinal_ = 7;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_max_node_name_size(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[8 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 8) {
+ max_ordinal_ = 8;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_fs_type(::llcpp::fuchsia::fs::FsType* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[9 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 9) {
+ max_ordinal_ = 9;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_name(::fidl::StringView* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[10 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 10) {
+ max_ordinal_ = 10;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::fs::FilesystemInfo::Builder::set_device_path(::fidl::StringView* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[11 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 11) {
+ max_ordinal_ = 11;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::fs::Query_GetInfo_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Query_GetInfo_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Query_GetInfo_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Query_GetInfo_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kQuery_GetInfo_Ordinal = 0x7e34516a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kQuery_GetInfo_GenOrdinal = 0x2bb3720da231852alu;
+extern "C" const fidl_type_t v1_fuchsia_fs_QueryGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fs_QueryGetInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kQuery_IsNodeInFilesystem_Ordinal = 0x2d124b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kQuery_IsNodeInFilesystem_GenOrdinal = 0x7dd26cb8c5e229elu;
+extern "C" const fidl_type_t v1_fuchsia_fs_QueryIsNodeInFilesystemRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fs_QueryIsNodeInFilesystemResponseTable;
+
+} // namespace
+template <>
+Query::ResultOf::GetInfo_Impl<Query::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::fs::FilesystemInfoQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetInfoRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Query::InPlace::GetInfo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Query::ResultOf::GetInfo Query::SyncClient::GetInfo(::llcpp::fuchsia::fs::FilesystemInfoQuery query) {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Query::ResultOf::GetInfo Query::Call::GetInfo(::zx::unowned_channel _client_end, ::llcpp::fuchsia::fs::FilesystemInfoQuery query) {
+ return ResultOf::GetInfo(std::move(_client_end), std::move(query));
+}
+
+template <>
+Query::UnownedResultOf::GetInfo_Impl<Query::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::fs::FilesystemInfoQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetInfoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetInfoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetInfoRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Query::InPlace::GetInfo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Query::UnownedResultOf::GetInfo Query::SyncClient::GetInfo(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::fs::FilesystemInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Query::UnownedResultOf::GetInfo Query::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::fs::FilesystemInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Query::GetInfoResponse> Query::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetInfoRequest> params, ::fidl::BytePart response_buffer) {
+ Query::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Query::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Query::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Query::ResultOf::IsNodeInFilesystem_Impl<Query::IsNodeInFilesystemResponse>::IsNodeInFilesystem_Impl(::zx::unowned_channel _client_end, ::zx::event token) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<IsNodeInFilesystemRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, IsNodeInFilesystemRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<IsNodeInFilesystemRequest*>(_write_bytes);
+ _request.token = std::move(token);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(IsNodeInFilesystemRequest));
+ ::fidl::DecodedMessage<IsNodeInFilesystemRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Query::InPlace::IsNodeInFilesystem(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Query::ResultOf::IsNodeInFilesystem Query::SyncClient::IsNodeInFilesystem(::zx::event token) {
+ return ResultOf::IsNodeInFilesystem(::zx::unowned_channel(this->channel_), std::move(token));
+}
+
+Query::ResultOf::IsNodeInFilesystem Query::Call::IsNodeInFilesystem(::zx::unowned_channel _client_end, ::zx::event token) {
+ return ResultOf::IsNodeInFilesystem(std::move(_client_end), std::move(token));
+}
+
+template <>
+Query::UnownedResultOf::IsNodeInFilesystem_Impl<Query::IsNodeInFilesystemResponse>::IsNodeInFilesystem_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::event token, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < IsNodeInFilesystemRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<IsNodeInFilesystemResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, IsNodeInFilesystemRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<IsNodeInFilesystemRequest*>(_request_buffer.data());
+ _request.token = std::move(token);
+ _request_buffer.set_actual(sizeof(IsNodeInFilesystemRequest));
+ ::fidl::DecodedMessage<IsNodeInFilesystemRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Query::InPlace::IsNodeInFilesystem(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Query::UnownedResultOf::IsNodeInFilesystem Query::SyncClient::IsNodeInFilesystem(::fidl::BytePart _request_buffer, ::zx::event token, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::IsNodeInFilesystem(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(token), std::move(_response_buffer));
+}
+
+Query::UnownedResultOf::IsNodeInFilesystem Query::Call::IsNodeInFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::event token, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::IsNodeInFilesystem(std::move(_client_end), std::move(_request_buffer), std::move(token), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Query::IsNodeInFilesystemResponse> Query::InPlace::IsNodeInFilesystem(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<IsNodeInFilesystemRequest> params, ::fidl::BytePart response_buffer) {
+ Query::SetTransactionHeaderFor::IsNodeInFilesystemRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Query::IsNodeInFilesystemResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<IsNodeInFilesystemRequest, IsNodeInFilesystemResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Query::IsNodeInFilesystemResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Query::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kQuery_GetInfo_Ordinal:
+ case kQuery_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetInfo(std::move(message->query),
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kQuery_IsNodeInFilesystem_Ordinal:
+ case kQuery_IsNodeInFilesystem_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<IsNodeInFilesystemRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->IsNodeInFilesystem(std::move(message->token),
+ Interface::IsNodeInFilesystemCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Query::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Query::Interface::GetInfoCompleterBase::Reply(::llcpp::fuchsia::fs::Query_GetInfo_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetInfoResponse _response = {};
+ Query::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Query::Interface::GetInfoCompleterBase::ReplySuccess(::llcpp::fuchsia::fs::FilesystemInfo info) {
+ Query_GetInfo_Response response;
+ response.info = std::move(info);
+
+ Reply(Query_GetInfo_Result::WithResponse(&response));
+}
+void Query::Interface::GetInfoCompleterBase::ReplyError(int32_t error) {
+ Reply(Query_GetInfo_Result::WithErr(&error));
+}
+
+void Query::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::fs::Query_GetInfo_Result result) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInfoResponse _response = {};
+ Query::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Query::Interface::GetInfoCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::fs::FilesystemInfo info) {
+ Query_GetInfo_Response response;
+ response.info = std::move(info);
+
+ Reply(std::move(_buffer), Query_GetInfo_Result::WithResponse(&response));
+}
+
+void Query::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ Query::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Query::Interface::IsNodeInFilesystemCompleterBase::Reply(bool is_in_filesystem) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<IsNodeInFilesystemResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<IsNodeInFilesystemResponse*>(_write_bytes);
+ Query::SetTransactionHeaderFor::IsNodeInFilesystemResponse(
+ ::fidl::DecodedMessage<IsNodeInFilesystemResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ IsNodeInFilesystemResponse::PrimarySize,
+ IsNodeInFilesystemResponse::PrimarySize)));
+ _response.is_in_filesystem = std::move(is_in_filesystem);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(IsNodeInFilesystemResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<IsNodeInFilesystemResponse>(std::move(_response_bytes)));
+}
+
+void Query::Interface::IsNodeInFilesystemCompleterBase::Reply(::fidl::BytePart _buffer, bool is_in_filesystem) {
+ if (_buffer.capacity() < IsNodeInFilesystemResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<IsNodeInFilesystemResponse*>(_buffer.data());
+ Query::SetTransactionHeaderFor::IsNodeInFilesystemResponse(
+ ::fidl::DecodedMessage<IsNodeInFilesystemResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ IsNodeInFilesystemResponse::PrimarySize,
+ IsNodeInFilesystemResponse::PrimarySize)));
+ _response.is_in_filesystem = std::move(is_in_filesystem);
+ _buffer.set_actual(sizeof(IsNodeInFilesystemResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<IsNodeInFilesystemResponse>(std::move(_buffer)));
+}
+
+void Query::Interface::IsNodeInFilesystemCompleterBase::Reply(::fidl::DecodedMessage<IsNodeInFilesystemResponse> params) {
+ Query::SetTransactionHeaderFor::IsNodeInFilesystemResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Query::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<Query::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kQuery_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Query::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<Query::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kQuery_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Query::SetTransactionHeaderFor::IsNodeInFilesystemRequest(const ::fidl::DecodedMessage<Query::IsNodeInFilesystemRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kQuery_IsNodeInFilesystem_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Query::SetTransactionHeaderFor::IsNodeInFilesystemResponse(const ::fidl::DecodedMessage<Query::IsNodeInFilesystemResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kQuery_IsNodeInFilesystem_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace fs
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-fs/gen/llcpp/include/fuchsia/fs/llcpp/fidl.h b/zircon/system/fidl/fuchsia-fs/gen/llcpp/include/fuchsia/fs/llcpp/fidl.h
new file mode 100644
index 0000000..d823a5e
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-fs/gen/llcpp/include/fuchsia/fs/llcpp/fidl.h
@@ -0,0 +1,1008 @@
+// 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/event.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/io2/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace fs {
+
+class Admin;
+enum class FsType : uint32_t {
+ BLOBFS = 2657701153u,
+ MINFS = 1852394785u,
+ MEMFS = 1047088417u,
+};
+
+
+struct FilesystemInfo;
+struct Query_GetInfo_Response;
+struct Query_GetInfo_Result;
+class FilesystemInfoQuery final {
+public:
+ constexpr FilesystemInfoQuery() : value_(0u) {}
+ explicit constexpr FilesystemInfoQuery(uint64_t value) : value_(value) {}
+ const static FilesystemInfoQuery TOTAL_BYTES;
+ const static FilesystemInfoQuery USED_BYTES;
+ const static FilesystemInfoQuery TOTAL_NODES;
+ const static FilesystemInfoQuery USED_NODES;
+ const static FilesystemInfoQuery FREE_SHARED_POOL_BYTES;
+ const static FilesystemInfoQuery FS_ID;
+ const static FilesystemInfoQuery BLOCK_SIZE;
+ const static FilesystemInfoQuery MAX_NODE_NAME_SIZE;
+ const static FilesystemInfoQuery FS_TYPE;
+ const static FilesystemInfoQuery NAME;
+ const static FilesystemInfoQuery DEVICE_PATH;
+ const static FilesystemInfoQuery mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const FilesystemInfoQuery& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const FilesystemInfoQuery& other) const { return value_ != other.value_; }
+ constexpr inline FilesystemInfoQuery operator~() const;
+ constexpr inline FilesystemInfoQuery operator|(const FilesystemInfoQuery& other) const;
+ constexpr inline FilesystemInfoQuery operator&(const FilesystemInfoQuery& other) const;
+ constexpr inline FilesystemInfoQuery operator^(const FilesystemInfoQuery& other) const;
+ constexpr inline void operator|=(const FilesystemInfoQuery& other);
+ constexpr inline void operator&=(const FilesystemInfoQuery& other);
+ constexpr inline void operator^=(const FilesystemInfoQuery& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::TOTAL_BYTES = ::llcpp::fuchsia::fs::FilesystemInfoQuery(1u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::USED_BYTES = ::llcpp::fuchsia::fs::FilesystemInfoQuery(2u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::TOTAL_NODES = ::llcpp::fuchsia::fs::FilesystemInfoQuery(4u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::USED_NODES = ::llcpp::fuchsia::fs::FilesystemInfoQuery(8u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::FREE_SHARED_POOL_BYTES = ::llcpp::fuchsia::fs::FilesystemInfoQuery(16u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::FS_ID = ::llcpp::fuchsia::fs::FilesystemInfoQuery(32u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::BLOCK_SIZE = ::llcpp::fuchsia::fs::FilesystemInfoQuery(64u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::MAX_NODE_NAME_SIZE = ::llcpp::fuchsia::fs::FilesystemInfoQuery(128u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::FS_TYPE = ::llcpp::fuchsia::fs::FilesystemInfoQuery(256u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::NAME = ::llcpp::fuchsia::fs::FilesystemInfoQuery(512u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::DEVICE_PATH = ::llcpp::fuchsia::fs::FilesystemInfoQuery(1024u);
+constexpr const ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::mask = ::llcpp::fuchsia::fs::FilesystemInfoQuery(2047u);
+
+constexpr inline ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::operator~() const {
+ return ::llcpp::fuchsia::fs::FilesystemInfoQuery(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::operator|(
+ const ::llcpp::fuchsia::fs::FilesystemInfoQuery& other) const {
+ return ::llcpp::fuchsia::fs::FilesystemInfoQuery(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::operator&(
+ const ::llcpp::fuchsia::fs::FilesystemInfoQuery& other) const {
+ return ::llcpp::fuchsia::fs::FilesystemInfoQuery(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::fs::FilesystemInfoQuery FilesystemInfoQuery::operator^(
+ const ::llcpp::fuchsia::fs::FilesystemInfoQuery& other) const {
+ return ::llcpp::fuchsia::fs::FilesystemInfoQuery(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void FilesystemInfoQuery::operator|=(
+ const ::llcpp::fuchsia::fs::FilesystemInfoQuery& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void FilesystemInfoQuery::operator&=(
+ const ::llcpp::fuchsia::fs::FilesystemInfoQuery& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void FilesystemInfoQuery::operator^=(
+ const ::llcpp::fuchsia::fs::FilesystemInfoQuery& other) {
+ this->value_ ^= other.value_;
+}
+
+class Query;
+
+extern "C" const fidl_type_t v1_fuchsia_fs_FilesystemInfoTable;
+
+// Information about a filesystem.
+//
+// If a particular field is not applicable or not supported, implementations
+// should leave it absent.
+struct FilesystemInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The number of data bytes which may be stored in the filesystem.
+ const uint64_t& total_bytes() const {
+ ZX_ASSERT(has_total_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ uint64_t& total_bytes() {
+ ZX_ASSERT(has_total_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_total_bytes() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // The number of data bytes which are in use by the filesystem.
+ // Note that this value may change in the mean time.
+ const uint64_t& used_bytes() const {
+ ZX_ASSERT(has_used_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ uint64_t& used_bytes() {
+ ZX_ASSERT(has_used_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_used_bytes() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // The number of nodes which may be stored in the filesystem.
+ const uint64_t& total_nodes() const {
+ ZX_ASSERT(has_total_nodes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ uint64_t& total_nodes() {
+ ZX_ASSERT(has_total_nodes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_total_nodes() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // The number of nodes used by the filesystem.
+ // Note that this value may change in the mean time.
+ const uint64_t& used_nodes() const {
+ ZX_ASSERT(has_used_nodes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ uint64_t& used_nodes() {
+ ZX_ASSERT(has_used_nodes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_used_nodes() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ // The amount of space which may be allocated from the underlying
+ // volume manager. Note that this value may change in the mean time.
+ const uint64_t& free_shared_pool_bytes() const {
+ ZX_ASSERT(has_free_shared_pool_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ uint64_t& free_shared_pool_bytes() {
+ ZX_ASSERT(has_free_shared_pool_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_free_shared_pool_bytes() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ // A globally unique identifier for this filesystem instance.
+ const ::zx::event& fs_id() const {
+ ZX_ASSERT(has_fs_id());
+ return *reinterpret_cast<const ::zx::event*>(EnvelopesView::at(6 - 1).data);
+ }
+ ::zx::event& fs_id() {
+ ZX_ASSERT(has_fs_id());
+ return *reinterpret_cast<::zx::event*>(EnvelopesView::at(6 - 1).data);
+ }
+ bool has_fs_id() const {
+ return EnvelopesView::count() >= 6 && EnvelopesView::at(6 - 1).data != nullptr;
+ }
+
+ // The size of a single filesystem block.
+ const uint32_t& block_size() const {
+ ZX_ASSERT(has_block_size());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(7 - 1).data);
+ }
+ uint32_t& block_size() {
+ ZX_ASSERT(has_block_size());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(7 - 1).data);
+ }
+ bool has_block_size() const {
+ return EnvelopesView::count() >= 7 && EnvelopesView::at(7 - 1).data != nullptr;
+ }
+
+ // The maximum length of a filesystem name.
+ const uint32_t& max_node_name_size() const {
+ ZX_ASSERT(has_max_node_name_size());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(8 - 1).data);
+ }
+ uint32_t& max_node_name_size() {
+ ZX_ASSERT(has_max_node_name_size());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(8 - 1).data);
+ }
+ bool has_max_node_name_size() const {
+ return EnvelopesView::count() >= 8 && EnvelopesView::at(8 - 1).data != nullptr;
+ }
+
+ // A unique identifier for the type of the underlying filesystem.
+ const ::llcpp::fuchsia::fs::FsType& fs_type() const {
+ ZX_ASSERT(has_fs_type());
+ return *reinterpret_cast<const ::llcpp::fuchsia::fs::FsType*>(EnvelopesView::at(9 - 1).data);
+ }
+ ::llcpp::fuchsia::fs::FsType& fs_type() {
+ ZX_ASSERT(has_fs_type());
+ return *reinterpret_cast<::llcpp::fuchsia::fs::FsType*>(EnvelopesView::at(9 - 1).data);
+ }
+ bool has_fs_type() const {
+ return EnvelopesView::count() >= 9 && EnvelopesView::at(9 - 1).data != nullptr;
+ }
+
+ // The name of the filesystem.
+ const ::fidl::StringView& name() const {
+ ZX_ASSERT(has_name());
+ return *reinterpret_cast<const ::fidl::StringView*>(EnvelopesView::at(10 - 1).data);
+ }
+ ::fidl::StringView& name() {
+ ZX_ASSERT(has_name());
+ return *reinterpret_cast<::fidl::StringView*>(EnvelopesView::at(10 - 1).data);
+ }
+ bool has_name() const {
+ return EnvelopesView::count() >= 10 && EnvelopesView::at(10 - 1).data != nullptr;
+ }
+
+ // Path to the device backing this filesystem.
+ const ::fidl::StringView& device_path() const {
+ ZX_ASSERT(has_device_path());
+ return *reinterpret_cast<const ::fidl::StringView*>(EnvelopesView::at(11 - 1).data);
+ }
+ ::fidl::StringView& device_path() {
+ ZX_ASSERT(has_device_path());
+ return *reinterpret_cast<::fidl::StringView*>(EnvelopesView::at(11 - 1).data);
+ }
+ bool has_device_path() const {
+ return EnvelopesView::count() >= 11 && EnvelopesView::at(11 - 1).data != nullptr;
+ }
+
+ FilesystemInfo() = default;
+ ~FilesystemInfo() = default;
+ FilesystemInfo(FilesystemInfo&& other) noexcept = default;
+ FilesystemInfo& operator=(FilesystemInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fs_FilesystemInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4408;
+ static constexpr bool HasPointer = true;
+
+ private:
+ FilesystemInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class FilesystemInfo::Builder {
+ public:
+ FilesystemInfo view() { return FilesystemInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The number of data bytes which may be stored in the filesystem.
+ Builder&& set_total_bytes(uint64_t* elem);
+
+ // The number of data bytes which are in use by the filesystem.
+ // Note that this value may change in the mean time.
+ Builder&& set_used_bytes(uint64_t* elem);
+
+ // The number of nodes which may be stored in the filesystem.
+ Builder&& set_total_nodes(uint64_t* elem);
+
+ // The number of nodes used by the filesystem.
+ // Note that this value may change in the mean time.
+ Builder&& set_used_nodes(uint64_t* elem);
+
+ // The amount of space which may be allocated from the underlying
+ // volume manager. Note that this value may change in the mean time.
+ Builder&& set_free_shared_pool_bytes(uint64_t* elem);
+
+ // A globally unique identifier for this filesystem instance.
+ Builder&& set_fs_id(::zx::event* elem);
+
+ // The size of a single filesystem block.
+ Builder&& set_block_size(uint32_t* elem);
+
+ // The maximum length of a filesystem name.
+ Builder&& set_max_node_name_size(uint32_t* elem);
+
+ // A unique identifier for the type of the underlying filesystem.
+ Builder&& set_fs_type(::llcpp::fuchsia::fs::FsType* elem);
+
+ // The name of the filesystem.
+ Builder&& set_name(::fidl::StringView* elem);
+
+ // Path to the device backing this filesystem.
+ Builder&& set_device_path(::fidl::StringView* elem);
+
+ private:
+ Builder() = default;
+ friend Builder FilesystemInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 11> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_fs_Query_GetInfo_ResultTable;
+
+struct Query_GetInfo_Result {
+ Query_GetInfo_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Query_GetInfo_Result WithResponse(::llcpp::fuchsia::fs::Query_GetInfo_Response* val) {
+ Query_GetInfo_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::fs::Query_GetInfo_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::fs::Query_GetInfo_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::fs::Query_GetInfo_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::fs::Query_GetInfo_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::fs::Query_GetInfo_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Query_GetInfo_Result WithErr(int32_t* val) {
+ Query_GetInfo_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fs_Query_GetInfo_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4424;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_fs_AdminShutdownRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fs_AdminShutdownResponseTable;
+// Administration functionality for filesystems.
+class Admin final {
+ Admin() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.fs.Admin";
+
+ using ShutdownResponse = ::fidl::AnyZeroArgMessage;
+ using ShutdownRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Shutdown_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Shutdown_Impl(::zx::unowned_channel _client_end);
+ ~Shutdown_Impl() = default;
+ Shutdown_Impl(Shutdown_Impl&& other) = default;
+ Shutdown_Impl& operator=(Shutdown_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 Shutdown = Shutdown_Impl<ShutdownResponse>;
+ };
+
+ // 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 Shutdown_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Shutdown_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Shutdown_Impl() = default;
+ Shutdown_Impl(Shutdown_Impl&& other) = default;
+ Shutdown_Impl& operator=(Shutdown_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 Shutdown = Shutdown_Impl<ShutdownResponse>;
+ };
+
+ 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_; }
+
+ // Shuts down the filesystem. Once the filesystem recieves the shutdown request, it will
+ // complete any active requests before terminating, but will not respond to new requests. This
+ // call blocks until all open connections to the filesystem are terminated and any underlying
+ // block devices or other owned channels are released, then it responds to this request and
+ // closes this channel.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Shutdown Shutdown();
+
+
+ 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:
+
+ // Shuts down the filesystem. Once the filesystem recieves the shutdown request, it will
+ // complete any active requests before terminating, but will not respond to new requests. This
+ // call blocks until all open connections to the filesystem are terminated and any underlying
+ // block devices or other owned channels are released, then it responds to this request and
+ // closes this channel.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Shutdown Shutdown(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // Shuts down the filesystem. Once the filesystem recieves the shutdown request, it will
+ // complete any active requests before terminating, but will not respond to new requests. This
+ // call blocks until all open connections to the filesystem are terminated and any underlying
+ // block devices or other owned channels are released, then it responds to this request and
+ // closes this channel.
+ static ::fidl::DecodeResult<ShutdownResponse> Shutdown(::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 = Admin;
+ using _Base = ::fidl::CompleterBase;
+
+ class ShutdownCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ShutdownCompleter = ::fidl::Completer<ShutdownCompleterBase>;
+
+ virtual void Shutdown(ShutdownCompleter::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 ShutdownRequest(const ::fidl::DecodedMessage<Admin::ShutdownRequest>& _msg);
+ static void ShutdownResponse(const ::fidl::DecodedMessage<Admin::ShutdownResponse>& _msg);
+ };
+};
+
+// The maximum length of the name of a filesystem.
+constexpr uint64_t MAX_FS_NAME_LENGTH = 32u;
+
+extern "C" const fidl_type_t v1_fuchsia_fs_Query_GetInfo_ResponseTable;
+
+struct Query_GetInfo_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fs_Query_GetInfo_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4408;
+ static constexpr bool HasPointer = true;
+
+ ::llcpp::fuchsia::fs::FilesystemInfo info = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_fs_QueryGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fs_QueryGetInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fs_QueryIsNodeInFilesystemRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fs_QueryIsNodeInFilesystemResponseTable;
+
+// `Query` exposes objective filesystem information independent of specific
+// files and directories.
+class Query final {
+ Query() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.fs.Query";
+
+ struct GetInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::fs::Query_GetInfo_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fs_QueryGetInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 4424;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetInfoRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::fs::FilesystemInfoQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fs_QueryGetInfoRequestTable;
+ 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 = GetInfoResponse;
+ };
+
+ struct IsNodeInFilesystemResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool is_in_filesystem;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fs_QueryIsNodeInFilesystemResponseTable;
+ 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 IsNodeInFilesystemRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::event token;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fs_QueryIsNodeInFilesystemRequestTable;
+ 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 = IsNodeInFilesystemResponse;
+ };
+
+
+ // 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, ::llcpp::fuchsia::fs::FilesystemInfoQuery query);
+ ~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 IsNodeInFilesystem_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ IsNodeInFilesystem_Impl(::zx::unowned_channel _client_end, ::zx::event token);
+ ~IsNodeInFilesystem_Impl() = default;
+ IsNodeInFilesystem_Impl(IsNodeInFilesystem_Impl&& other) = default;
+ IsNodeInFilesystem_Impl& operator=(IsNodeInFilesystem_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 IsNodeInFilesystem = IsNodeInFilesystem_Impl<IsNodeInFilesystemResponse>;
+ };
+
+ // 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 _request_buffer, ::llcpp::fuchsia::fs::FilesystemInfoQuery query, ::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 IsNodeInFilesystem_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ IsNodeInFilesystem_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::event token, ::fidl::BytePart _response_buffer);
+ ~IsNodeInFilesystem_Impl() = default;
+ IsNodeInFilesystem_Impl(IsNodeInFilesystem_Impl&& other) = default;
+ IsNodeInFilesystem_Impl& operator=(IsNodeInFilesystem_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 IsNodeInFilesystem = IsNodeInFilesystem_Impl<IsNodeInFilesystemResponse>;
+ };
+
+ 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_; }
+
+ // Queries the filesystem.
+ //
+ // + `query` specifies the fields in `FilesystemInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.fs/FilesystemInfo`] for details on the fields.
+ //
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetInfo GetInfo(::llcpp::fuchsia::fs::FilesystemInfoQuery query);
+
+ // Queries the filesystem.
+ //
+ // + `query` specifies the fields in `FilesystemInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.fs/FilesystemInfo`] for details on the fields.
+ //
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetInfo GetInfo(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::fs::FilesystemInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Checks if a node is associated with this filesystem, given some token
+ // representing a connection to that node.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::IsNodeInFilesystem IsNodeInFilesystem(::zx::event token);
+
+ // Checks if a node is associated with this filesystem, given some token
+ // representing a connection to that node.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::IsNodeInFilesystem IsNodeInFilesystem(::fidl::BytePart _request_buffer, ::zx::event token, ::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:
+
+ // Queries the filesystem.
+ //
+ // + `query` specifies the fields in `FilesystemInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.fs/FilesystemInfo`] for details on the fields.
+ //
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end, ::llcpp::fuchsia::fs::FilesystemInfoQuery query);
+
+ // Queries the filesystem.
+ //
+ // + `query` specifies the fields in `FilesystemInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.fs/FilesystemInfo`] for details on the fields.
+ //
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::fs::FilesystemInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Checks if a node is associated with this filesystem, given some token
+ // representing a connection to that node.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::IsNodeInFilesystem IsNodeInFilesystem(::zx::unowned_channel _client_end, ::zx::event token);
+
+ // Checks if a node is associated with this filesystem, given some token
+ // representing a connection to that node.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::IsNodeInFilesystem IsNodeInFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::event token, ::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:
+
+ // Queries the filesystem.
+ //
+ // + `query` specifies the fields in `FilesystemInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.fs/FilesystemInfo`] for details on the fields.
+ //
+ static ::fidl::DecodeResult<GetInfoResponse> GetInfo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetInfoRequest> params, ::fidl::BytePart response_buffer);
+
+ // Checks if a node is associated with this filesystem, given some token
+ // representing a connection to that node.
+ static ::fidl::DecodeResult<IsNodeInFilesystemResponse> IsNodeInFilesystem(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<IsNodeInFilesystemRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Query;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetInfoCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::fs::Query_GetInfo_Result result);
+ void ReplySuccess(::llcpp::fuchsia::fs::FilesystemInfo info);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::fs::Query_GetInfo_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::fs::FilesystemInfo info);
+ void Reply(::fidl::DecodedMessage<GetInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetInfoCompleter = ::fidl::Completer<GetInfoCompleterBase>;
+
+ virtual void GetInfo(::llcpp::fuchsia::fs::FilesystemInfoQuery query, GetInfoCompleter::Sync _completer) = 0;
+
+ class IsNodeInFilesystemCompleterBase : public _Base {
+ public:
+ void Reply(bool is_in_filesystem);
+ void Reply(::fidl::BytePart _buffer, bool is_in_filesystem);
+ void Reply(::fidl::DecodedMessage<IsNodeInFilesystemResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using IsNodeInFilesystemCompleter = ::fidl::Completer<IsNodeInFilesystemCompleterBase>;
+
+ virtual void IsNodeInFilesystem(::zx::event token, IsNodeInFilesystemCompleter::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<Query::GetInfoRequest>& _msg);
+ static void GetInfoResponse(const ::fidl::DecodedMessage<Query::GetInfoResponse>& _msg);
+ static void IsNodeInFilesystemRequest(const ::fidl::DecodedMessage<Query::IsNodeInFilesystemRequest>& _msg);
+ static void IsNodeInFilesystemResponse(const ::fidl::DecodedMessage<Query::IsNodeInFilesystemResponse>& _msg);
+ };
+};
+
+} // namespace fs
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fs::FilesystemInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::fs::FilesystemInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fs::Query_GetInfo_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::fs::Query_GetInfo_Response>);
+static_assert(offsetof(::llcpp::fuchsia::fs::Query_GetInfo_Response, info) == 0);
+static_assert(sizeof(::llcpp::fuchsia::fs::Query_GetInfo_Response) == ::llcpp::fuchsia::fs::Query_GetInfo_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fs::Query_GetInfo_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::fs::Query_GetInfo_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fs::FilesystemInfoQuery> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::fs::FilesystemInfoQuery>);
+static_assert(sizeof(::llcpp::fuchsia::fs::FilesystemInfoQuery) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fs::Query::GetInfoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fs::Query::GetInfoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fs::Query::GetInfoRequest)
+ == ::llcpp::fuchsia::fs::Query::GetInfoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fs::Query::GetInfoRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fs::Query::GetInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fs::Query::GetInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fs::Query::GetInfoResponse)
+ == ::llcpp::fuchsia::fs::Query::GetInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fs::Query::GetInfoResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fs::Query::IsNodeInFilesystemRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fs::Query::IsNodeInFilesystemRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fs::Query::IsNodeInFilesystemRequest)
+ == ::llcpp::fuchsia::fs::Query::IsNodeInFilesystemRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fs::Query::IsNodeInFilesystemRequest, token) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fs::Query::IsNodeInFilesystemResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fs::Query::IsNodeInFilesystemResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fs::Query::IsNodeInFilesystemResponse)
+ == ::llcpp::fuchsia::fs::Query::IsNodeInFilesystemResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fs::Query::IsNodeInFilesystemResponse, is_in_filesystem) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-fshost/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-fshost/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..b208576
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-fshost/gen/llcpp/fidl.cc
@@ -0,0 +1,2454 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/fshost/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace fshost {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Open_Ordinal = 0x77e4cceb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Open_GenOrdinal = 0x2c5044561d685ec0lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsOpenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Unlink_Ordinal = 0x2cbadb1900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Unlink_GenOrdinal = 0x5a0ff90760a8bc23lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsUnlinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsUnlinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_ReadDirents_Ordinal = 0x2ea53c2d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_ReadDirents_GenOrdinal = 0x3582806bf27faa0alu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsReadDirentsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsReadDirentsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Rewind_Ordinal = 0x7072fd8700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Rewind_GenOrdinal = 0x16b1202af0f34c71lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsRewindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsRewindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_GetToken_Ordinal = 0x3217bced00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_GetToken_GenOrdinal = 0x26ae9d18763c8655lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Rename_Ordinal = 0x4a94b0ac00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Rename_GenOrdinal = 0xa8e00a247f3c905lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsRenameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsRenameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Link_Ordinal = 0x1b8a5e6400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Link_GenOrdinal = 0x740604c0c7c930e7lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsLinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsLinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Watch_Ordinal = 0x5ac28f3400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFilesystems_Watch_GenOrdinal = 0x5717193a59d66d91lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsWatchResponseTable;
+
+} // namespace
+
+Filesystems::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Filesystems::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Filesystems::ResultOf::Clone Filesystems::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+Filesystems::ResultOf::Clone Filesystems::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+Filesystems::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Filesystems::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Filesystems::UnownedResultOf::Clone Filesystems::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+Filesystems::UnownedResultOf::Clone Filesystems::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError Filesystems::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ Filesystems::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Filesystems::ResultOf::Close_Impl<Filesystems::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::Close Filesystems::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Filesystems::ResultOf::Close Filesystems::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+Filesystems::UnownedResultOf::Close_Impl<Filesystems::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::Close Filesystems::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::Close Filesystems::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::CloseResponse> Filesystems::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Filesystems::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::Describe_Impl<Filesystems::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::Describe Filesystems::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+Filesystems::ResultOf::Describe Filesystems::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+Filesystems::UnownedResultOf::Describe_Impl<Filesystems::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::Describe Filesystems::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::Describe Filesystems::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::DescribeResponse> Filesystems::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ Filesystems::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::Sync_Impl<Filesystems::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::Sync Filesystems::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Filesystems::ResultOf::Sync Filesystems::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Filesystems::UnownedResultOf::Sync_Impl<Filesystems::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::Sync Filesystems::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::Sync Filesystems::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::SyncResponse> Filesystems::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Filesystems::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::GetAttr_Impl<Filesystems::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::GetAttr Filesystems::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+Filesystems::ResultOf::GetAttr Filesystems::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+Filesystems::UnownedResultOf::GetAttr_Impl<Filesystems::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::GetAttr Filesystems::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::GetAttr Filesystems::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::GetAttrResponse> Filesystems::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ Filesystems::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::SetAttr_Impl<Filesystems::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::SetAttr Filesystems::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+Filesystems::ResultOf::SetAttr Filesystems::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+Filesystems::UnownedResultOf::SetAttr_Impl<Filesystems::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::SetAttr Filesystems::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::SetAttr Filesystems::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::SetAttrResponse> Filesystems::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ Filesystems::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::NodeGetFlags_Impl<Filesystems::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::NodeGetFlags Filesystems::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+Filesystems::ResultOf::NodeGetFlags Filesystems::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+Filesystems::UnownedResultOf::NodeGetFlags_Impl<Filesystems::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::NodeGetFlags Filesystems::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::NodeGetFlags Filesystems::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::NodeGetFlagsResponse> Filesystems::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ Filesystems::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::NodeSetFlags_Impl<Filesystems::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::NodeSetFlags Filesystems::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Filesystems::ResultOf::NodeSetFlags Filesystems::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Filesystems::UnownedResultOf::NodeSetFlags_Impl<Filesystems::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::NodeSetFlags Filesystems::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::NodeSetFlags Filesystems::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::NodeSetFlagsResponse> Filesystems::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ Filesystems::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Filesystems::ResultOf::Open_Impl::Open_Impl(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ OpenRequest _request = {};
+ _request.flags = std::move(flags);
+ _request.mode = std::move(mode);
+ _request.path = std::move(path);
+ _request.object = std::move(object);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Filesystems::InPlace::Open(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Filesystems::ResultOf::Open Filesystems::SyncClient::Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return ResultOf::Open(::zx::unowned_channel(this->channel_), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+Filesystems::ResultOf::Open Filesystems::Call::Open(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return ResultOf::Open(std::move(_client_end), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+
+Filesystems::UnownedResultOf::Open_Impl::Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ if (_request_buffer.capacity() < OpenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ OpenRequest _request = {};
+ _request.flags = std::move(flags);
+ _request.mode = std::move(mode);
+ _request.path = std::move(path);
+ _request.object = std::move(object);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Filesystems::InPlace::Open(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Filesystems::UnownedResultOf::Open Filesystems::SyncClient::Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return UnownedResultOf::Open(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+Filesystems::UnownedResultOf::Open Filesystems::Call::Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return UnownedResultOf::Open(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+::fidl::internal::StatusAndError Filesystems::InPlace::Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params) {
+ Filesystems::SetTransactionHeaderFor::OpenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Filesystems::ResultOf::Unlink_Impl<Filesystems::UnlinkResponse>::Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ UnlinkRequest _request = {};
+ _request.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Filesystems::InPlace::Unlink(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::Unlink Filesystems::SyncClient::Unlink(::fidl::StringView path) {
+ return ResultOf::Unlink(::zx::unowned_channel(this->channel_), std::move(path));
+}
+
+Filesystems::ResultOf::Unlink Filesystems::Call::Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path) {
+ return ResultOf::Unlink(std::move(_client_end), std::move(path));
+}
+
+template <>
+Filesystems::UnownedResultOf::Unlink_Impl<Filesystems::UnlinkResponse>::Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UnlinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UnlinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UnlinkRequest _request = {};
+ _request.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Filesystems::InPlace::Unlink(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::Unlink Filesystems::SyncClient::Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unlink(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(path), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::Unlink Filesystems::Call::Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unlink(std::move(_client_end), std::move(_request_buffer), std::move(path), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::UnlinkResponse> Filesystems::InPlace::Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer) {
+ Filesystems::SetTransactionHeaderFor::UnlinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::UnlinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::UnlinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::ReadDirents_Impl<Filesystems::ReadDirentsResponse>::ReadDirents_Impl(::zx::unowned_channel _client_end, uint64_t max_bytes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirentsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadDirentsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadDirentsRequest*>(_write_bytes);
+ _request.max_bytes = std::move(max_bytes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadDirentsRequest));
+ ::fidl::DecodedMessage<ReadDirentsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::ReadDirents(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::ReadDirents Filesystems::SyncClient::ReadDirents(uint64_t max_bytes) {
+ return ResultOf::ReadDirents(::zx::unowned_channel(this->channel_), std::move(max_bytes));
+}
+
+Filesystems::ResultOf::ReadDirents Filesystems::Call::ReadDirents(::zx::unowned_channel _client_end, uint64_t max_bytes) {
+ return ResultOf::ReadDirents(std::move(_client_end), std::move(max_bytes));
+}
+
+template <>
+Filesystems::UnownedResultOf::ReadDirents_Impl<Filesystems::ReadDirentsResponse>::ReadDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadDirentsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadDirentsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadDirentsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadDirentsRequest*>(_request_buffer.data());
+ _request.max_bytes = std::move(max_bytes);
+ _request_buffer.set_actual(sizeof(ReadDirentsRequest));
+ ::fidl::DecodedMessage<ReadDirentsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::ReadDirents(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::ReadDirents Filesystems::SyncClient::ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadDirents(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(max_bytes), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::ReadDirents Filesystems::Call::ReadDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadDirents(std::move(_client_end), std::move(_request_buffer), std::move(max_bytes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::ReadDirentsResponse> Filesystems::InPlace::ReadDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer) {
+ Filesystems::SetTransactionHeaderFor::ReadDirentsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::ReadDirentsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadDirentsRequest, ReadDirentsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::ReadDirentsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::Rewind_Impl<Filesystems::RewindResponse>::Rewind_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RewindRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindRequest));
+ ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::Rewind(std::move(_client_end), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::Rewind Filesystems::SyncClient::Rewind() {
+ return ResultOf::Rewind(::zx::unowned_channel(this->channel_));
+}
+
+Filesystems::ResultOf::Rewind Filesystems::Call::Rewind(::zx::unowned_channel _client_end) {
+ return ResultOf::Rewind(std::move(_client_end));
+}
+
+template <>
+Filesystems::UnownedResultOf::Rewind_Impl<Filesystems::RewindResponse>::Rewind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RewindRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, RewindRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(RewindRequest));
+ ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::Rewind(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::Rewind Filesystems::SyncClient::Rewind(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rewind(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::Rewind Filesystems::Call::Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rewind(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::RewindResponse> Filesystems::InPlace::Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(RewindRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<RewindRequest> params(std::move(_request_buffer));
+ Filesystems::SetTransactionHeaderFor::RewindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::RewindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::RewindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::GetToken_Impl<Filesystems::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::GetToken Filesystems::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+Filesystems::ResultOf::GetToken Filesystems::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+Filesystems::UnownedResultOf::GetToken_Impl<Filesystems::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::GetToken Filesystems::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::GetToken Filesystems::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::GetTokenResponse> Filesystems::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ Filesystems::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::Rename_Impl<Filesystems::RenameResponse>::Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ RenameRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Filesystems::InPlace::Rename(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::Rename Filesystems::SyncClient::Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Rename(::zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+Filesystems::ResultOf::Rename Filesystems::Call::Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Rename(std::move(_client_end), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+template <>
+Filesystems::UnownedResultOf::Rename_Impl<Filesystems::RenameResponse>::Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RenameRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RenameResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ RenameRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Filesystems::InPlace::Rename(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::Rename Filesystems::SyncClient::Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rename(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::Rename Filesystems::Call::Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rename(std::move(_client_end), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::RenameResponse> Filesystems::InPlace::Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer) {
+ Filesystems::SetTransactionHeaderFor::RenameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::RenameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::RenameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::Link_Impl<Filesystems::LinkResponse>::Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LinkRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Filesystems::InPlace::Link(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::Link Filesystems::SyncClient::Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Link(::zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+Filesystems::ResultOf::Link Filesystems::Call::Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Link(std::move(_client_end), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+template <>
+Filesystems::UnownedResultOf::Link_Impl<Filesystems::LinkResponse>::Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LinkRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Filesystems::InPlace::Link(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::Link Filesystems::SyncClient::Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Link(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::Link Filesystems::Call::Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Link(std::move(_client_end), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::LinkResponse> Filesystems::InPlace::Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer) {
+ Filesystems::SetTransactionHeaderFor::LinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::LinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::LinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Filesystems::ResultOf::Watch_Impl<Filesystems::WatchResponse>::Watch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WatchRequest*>(_write_bytes);
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchRequest));
+ ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Filesystems::InPlace::Watch(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Filesystems::ResultOf::Watch Filesystems::SyncClient::Watch(uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ return ResultOf::Watch(::zx::unowned_channel(this->channel_), std::move(mask), std::move(options), std::move(watcher));
+}
+
+Filesystems::ResultOf::Watch Filesystems::Call::Watch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ return ResultOf::Watch(std::move(_client_end), std::move(mask), std::move(options), std::move(watcher));
+}
+
+template <>
+Filesystems::UnownedResultOf::Watch_Impl<Filesystems::WatchResponse>::Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WatchRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WatchResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WatchRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WatchRequest*>(_request_buffer.data());
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ _request_buffer.set_actual(sizeof(WatchRequest));
+ ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Filesystems::InPlace::Watch(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Filesystems::UnownedResultOf::Watch Filesystems::SyncClient::Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Watch(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
+}
+
+Filesystems::UnownedResultOf::Watch Filesystems::Call::Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Watch(std::move(_client_end), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Filesystems::WatchResponse> Filesystems::InPlace::Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer) {
+ Filesystems::SetTransactionHeaderFor::WatchRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::WatchResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Filesystems::WatchResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Filesystems::SyncClient::HandleEvents(Filesystems::EventHandlers handlers) {
+ return Filesystems::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Filesystems::Call::HandleEvents(::zx::unowned_channel client_end, Filesystems::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kFilesystems_OnOpen_Ordinal:
+ case kFilesystems_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Filesystems::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kFilesystems_Clone_Ordinal:
+ case kFilesystems_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Close_Ordinal:
+ case kFilesystems_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Describe_Ordinal:
+ case kFilesystems_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Sync_Ordinal:
+ case kFilesystems_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_GetAttr_Ordinal:
+ case kFilesystems_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_SetAttr_Ordinal:
+ case kFilesystems_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_NodeGetFlags_Ordinal:
+ case kFilesystems_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_NodeSetFlags_Ordinal:
+ case kFilesystems_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Open_Ordinal:
+ case kFilesystems_Open_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Open(std::move(message->flags), std::move(message->mode), std::move(message->path), std::move(message->object),
+ Interface::OpenCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Unlink_Ordinal:
+ case kFilesystems_Unlink_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnlinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Unlink(std::move(message->path),
+ Interface::UnlinkCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_ReadDirents_Ordinal:
+ case kFilesystems_ReadDirents_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadDirentsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReadDirents(std::move(message->max_bytes),
+ Interface::ReadDirentsCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Rewind_Ordinal:
+ case kFilesystems_Rewind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RewindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Rewind(
+ Interface::RewindCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_GetToken_Ordinal:
+ case kFilesystems_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Rename_Ordinal:
+ case kFilesystems_Rename_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RenameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Rename(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+ Interface::RenameCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Link_Ordinal:
+ case kFilesystems_Link_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Link(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+ Interface::LinkCompleter::Sync(txn));
+ return true;
+ }
+ case kFilesystems_Watch_Ordinal:
+ case kFilesystems_Watch_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Watch(std::move(message->mask), std::move(message->options), std::move(message->watcher),
+ Interface::WatchCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Filesystems::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Filesystems::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ Filesystems::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ Filesystems::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Filesystems::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Filesystems::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Filesystems::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Filesystems::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Filesystems::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ Filesystems::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Filesystems::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ Filesystems::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Filesystems::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ Filesystems::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Filesystems::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Filesystems::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ Filesystems::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ Filesystems::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ Filesystems::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ Filesystems::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::UnlinkCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<UnlinkResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::UnlinkResponse(
+ ::fidl::DecodedMessage<UnlinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnlinkResponse::PrimarySize,
+ UnlinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnlinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::UnlinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < UnlinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<UnlinkResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::UnlinkResponse(
+ ::fidl::DecodedMessage<UnlinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnlinkResponse::PrimarySize,
+ UnlinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(UnlinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::UnlinkCompleterBase::Reply(::fidl::DecodedMessage<UnlinkResponse> params) {
+ Filesystems::SetTransactionHeaderFor::UnlinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::ReadDirentsCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirentsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadDirentsResponse _response = {};
+ Filesystems::SetTransactionHeaderFor::ReadDirentsResponse(
+ ::fidl::DecodedMessage<ReadDirentsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDirentsResponse::PrimarySize,
+ ReadDirentsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Filesystems::Interface::ReadDirentsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+ if (_buffer.capacity() < ReadDirentsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadDirentsResponse _response = {};
+ Filesystems::SetTransactionHeaderFor::ReadDirentsResponse(
+ ::fidl::DecodedMessage<ReadDirentsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDirentsResponse::PrimarySize,
+ ReadDirentsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Filesystems::Interface::ReadDirentsCompleterBase::Reply(::fidl::DecodedMessage<ReadDirentsResponse> params) {
+ Filesystems::SetTransactionHeaderFor::ReadDirentsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::RewindCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RewindResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::RewindResponse(
+ ::fidl::DecodedMessage<RewindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RewindResponse::PrimarySize,
+ RewindResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::RewindCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < RewindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RewindResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::RewindResponse(
+ ::fidl::DecodedMessage<RewindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RewindResponse::PrimarySize,
+ RewindResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(RewindResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::RewindCompleterBase::Reply(::fidl::DecodedMessage<RewindResponse> params) {
+ Filesystems::SetTransactionHeaderFor::RewindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::GetTokenCompleterBase::Reply(int32_t s, ::zx::handle token) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetTokenResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.token = std::move(token);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetTokenResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.token = std::move(token);
+ _buffer.set_actual(sizeof(GetTokenResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ Filesystems::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::RenameCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RenameResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::RenameResponse(
+ ::fidl::DecodedMessage<RenameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RenameResponse::PrimarySize,
+ RenameResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RenameResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::RenameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < RenameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RenameResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::RenameResponse(
+ ::fidl::DecodedMessage<RenameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RenameResponse::PrimarySize,
+ RenameResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(RenameResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::RenameCompleterBase::Reply(::fidl::DecodedMessage<RenameResponse> params) {
+ Filesystems::SetTransactionHeaderFor::RenameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::LinkCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LinkResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::LinkResponse(
+ ::fidl::DecodedMessage<LinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LinkResponse::PrimarySize,
+ LinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::LinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < LinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LinkResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::LinkResponse(
+ ::fidl::DecodedMessage<LinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LinkResponse::PrimarySize,
+ LinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(LinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::LinkCompleterBase::Reply(::fidl::DecodedMessage<LinkResponse> params) {
+ Filesystems::SetTransactionHeaderFor::LinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Filesystems::Interface::WatchCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WatchResponse*>(_write_bytes);
+ Filesystems::SetTransactionHeaderFor::WatchResponse(
+ ::fidl::DecodedMessage<WatchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchResponse::PrimarySize,
+ WatchResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_response_bytes)));
+}
+
+void Filesystems::Interface::WatchCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < WatchResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WatchResponse*>(_buffer.data());
+ Filesystems::SetTransactionHeaderFor::WatchResponse(
+ ::fidl::DecodedMessage<WatchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchResponse::PrimarySize,
+ WatchResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(WatchResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_buffer)));
+}
+
+void Filesystems::Interface::WatchCompleterBase::Reply(::fidl::DecodedMessage<WatchResponse> params) {
+ Filesystems::SetTransactionHeaderFor::WatchResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Filesystems::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<Filesystems::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Filesystems::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<Filesystems::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Filesystems::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Filesystems::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<Filesystems::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Filesystems::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Filesystems::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<Filesystems::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<Filesystems::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<Filesystems::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<Filesystems::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<Filesystems::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<Filesystems::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<Filesystems::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<Filesystems::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::OpenRequest(const ::fidl::DecodedMessage<Filesystems::OpenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Open_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::UnlinkRequest(const ::fidl::DecodedMessage<Filesystems::UnlinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Unlink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::UnlinkResponse(const ::fidl::DecodedMessage<Filesystems::UnlinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Unlink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::ReadDirentsRequest(const ::fidl::DecodedMessage<Filesystems::ReadDirentsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_ReadDirents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::ReadDirentsResponse(const ::fidl::DecodedMessage<Filesystems::ReadDirentsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_ReadDirents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::RewindRequest(const ::fidl::DecodedMessage<Filesystems::RewindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Rewind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::RewindResponse(const ::fidl::DecodedMessage<Filesystems::RewindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Rewind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<Filesystems::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<Filesystems::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::RenameRequest(const ::fidl::DecodedMessage<Filesystems::RenameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Rename_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::RenameResponse(const ::fidl::DecodedMessage<Filesystems::RenameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Rename_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::LinkRequest(const ::fidl::DecodedMessage<Filesystems::LinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Link_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::LinkResponse(const ::fidl::DecodedMessage<Filesystems::LinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Link_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Filesystems::SetTransactionHeaderFor::WatchRequest(const ::fidl::DecodedMessage<Filesystems::WatchRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Watch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Filesystems::SetTransactionHeaderFor::WatchResponse(const ::fidl::DecodedMessage<Filesystems::WatchResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFilesystems_Watch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kAdmin_Shutdown_Ordinal = 0x2e0baed000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kAdmin_Shutdown_GenOrdinal = 0x7b8ebed9dd90dfbdlu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_AdminShutdownRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_AdminShutdownResponseTable;
+
+} // namespace
+template <>
+Admin::ResultOf::Shutdown_Impl<Admin::ShutdownResponse>::Shutdown_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShutdownRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ShutdownRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShutdownRequest));
+ ::fidl::DecodedMessage<ShutdownRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Admin::InPlace::Shutdown(std::move(_client_end), Super::response_buffer()));
+}
+
+Admin::ResultOf::Shutdown Admin::SyncClient::Shutdown() {
+ return ResultOf::Shutdown(::zx::unowned_channel(this->channel_));
+}
+
+Admin::ResultOf::Shutdown Admin::Call::Shutdown(::zx::unowned_channel _client_end) {
+ return ResultOf::Shutdown(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Admin::ShutdownResponse> Admin::InPlace::Shutdown(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ShutdownRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ShutdownRequest> params(std::move(_request_buffer));
+ Admin::SetTransactionHeaderFor::ShutdownRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Admin::ShutdownResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ShutdownRequest, ShutdownResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Admin::ShutdownResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Admin::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kAdmin_Shutdown_Ordinal:
+ case kAdmin_Shutdown_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ShutdownRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Shutdown(
+ Interface::ShutdownCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Admin::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Admin::Interface::ShutdownCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShutdownResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ShutdownResponse*>(_write_bytes);
+ Admin::SetTransactionHeaderFor::ShutdownResponse(
+ ::fidl::DecodedMessage<ShutdownResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ShutdownResponse::PrimarySize,
+ ShutdownResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShutdownResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ShutdownResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Admin::SetTransactionHeaderFor::ShutdownRequest(const ::fidl::DecodedMessage<Admin::ShutdownRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAdmin_Shutdown_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Admin::SetTransactionHeaderFor::ShutdownResponse(const ::fidl::DecodedMessage<Admin::ShutdownResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAdmin_Shutdown_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kRegistry_RegisterFilesystem_Ordinal = 0x459f2e5100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRegistry_RegisterFilesystem_GenOrdinal = 0x3dcc95b02284c9a2lu;
+extern "C" const fidl_type_t v1_fuchsia_fshost_RegistryRegisterFilesystemRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_RegistryRegisterFilesystemResponseTable;
+
+} // namespace
+template <>
+Registry::ResultOf::RegisterFilesystem_Impl<Registry::RegisterFilesystemResponse>::RegisterFilesystem_Impl(::zx::unowned_channel _client_end, ::zx::channel public_export) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RegisterFilesystemRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RegisterFilesystemRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RegisterFilesystemRequest*>(_write_bytes);
+ _request.public_export = std::move(public_export);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RegisterFilesystemRequest));
+ ::fidl::DecodedMessage<RegisterFilesystemRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Registry::InPlace::RegisterFilesystem(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Registry::ResultOf::RegisterFilesystem Registry::SyncClient::RegisterFilesystem(::zx::channel public_export) {
+ return ResultOf::RegisterFilesystem(::zx::unowned_channel(this->channel_), std::move(public_export));
+}
+
+Registry::ResultOf::RegisterFilesystem Registry::Call::RegisterFilesystem(::zx::unowned_channel _client_end, ::zx::channel public_export) {
+ return ResultOf::RegisterFilesystem(std::move(_client_end), std::move(public_export));
+}
+
+template <>
+Registry::UnownedResultOf::RegisterFilesystem_Impl<Registry::RegisterFilesystemResponse>::RegisterFilesystem_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel public_export, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RegisterFilesystemRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RegisterFilesystemResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RegisterFilesystemRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RegisterFilesystemRequest*>(_request_buffer.data());
+ _request.public_export = std::move(public_export);
+ _request_buffer.set_actual(sizeof(RegisterFilesystemRequest));
+ ::fidl::DecodedMessage<RegisterFilesystemRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Registry::InPlace::RegisterFilesystem(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Registry::UnownedResultOf::RegisterFilesystem Registry::SyncClient::RegisterFilesystem(::fidl::BytePart _request_buffer, ::zx::channel public_export, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RegisterFilesystem(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(public_export), std::move(_response_buffer));
+}
+
+Registry::UnownedResultOf::RegisterFilesystem Registry::Call::RegisterFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel public_export, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RegisterFilesystem(std::move(_client_end), std::move(_request_buffer), std::move(public_export), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Registry::RegisterFilesystemResponse> Registry::InPlace::RegisterFilesystem(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RegisterFilesystemRequest> params, ::fidl::BytePart response_buffer) {
+ Registry::SetTransactionHeaderFor::RegisterFilesystemRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Registry::RegisterFilesystemResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RegisterFilesystemRequest, RegisterFilesystemResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Registry::RegisterFilesystemResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Registry::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kRegistry_RegisterFilesystem_Ordinal:
+ case kRegistry_RegisterFilesystem_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RegisterFilesystemRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RegisterFilesystem(std::move(message->public_export),
+ Interface::RegisterFilesystemCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Registry::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Registry::Interface::RegisterFilesystemCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RegisterFilesystemResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RegisterFilesystemResponse*>(_write_bytes);
+ Registry::SetTransactionHeaderFor::RegisterFilesystemResponse(
+ ::fidl::DecodedMessage<RegisterFilesystemResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RegisterFilesystemResponse::PrimarySize,
+ RegisterFilesystemResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RegisterFilesystemResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RegisterFilesystemResponse>(std::move(_response_bytes)));
+}
+
+void Registry::Interface::RegisterFilesystemCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < RegisterFilesystemResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RegisterFilesystemResponse*>(_buffer.data());
+ Registry::SetTransactionHeaderFor::RegisterFilesystemResponse(
+ ::fidl::DecodedMessage<RegisterFilesystemResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RegisterFilesystemResponse::PrimarySize,
+ RegisterFilesystemResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(RegisterFilesystemResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RegisterFilesystemResponse>(std::move(_buffer)));
+}
+
+void Registry::Interface::RegisterFilesystemCompleterBase::Reply(::fidl::DecodedMessage<RegisterFilesystemResponse> params) {
+ Registry::SetTransactionHeaderFor::RegisterFilesystemResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Registry::SetTransactionHeaderFor::RegisterFilesystemRequest(const ::fidl::DecodedMessage<Registry::RegisterFilesystemRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRegistry_RegisterFilesystem_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Registry::SetTransactionHeaderFor::RegisterFilesystemResponse(const ::fidl::DecodedMessage<Registry::RegisterFilesystemResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRegistry_RegisterFilesystem_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace fshost
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-fshost/gen/llcpp/include/fuchsia/fshost/llcpp/fidl.h b/zircon/system/fidl/fuchsia-fshost/gen/llcpp/include/fuchsia/fshost/llcpp/fidl.h
new file mode 100644
index 0000000..60d7909
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-fshost/gen/llcpp/include/fuchsia/fshost/llcpp/fidl.h
@@ -0,0 +1,3033 @@
+// 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/handle.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/io/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace fshost {
+
+class Filesystems;
+class Admin;
+class Registry;
+
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsOpenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsUnlinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsUnlinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsReadDirentsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsReadDirentsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsRewindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsRewindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsRenameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsRenameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsLinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsLinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_FilesystemsWatchResponseTable;
+
+// A collection of all registered filesystems.
+class Filesystems final {
+ Filesystems() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.fshost.Filesystems";
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct OpenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ uint32_t mode;
+ ::fidl::StringView path;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsOpenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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;
+ };
+
+ struct UnlinkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsUnlinkResponseTable;
+ 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 UnlinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView path;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsUnlinkRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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 = UnlinkResponse;
+ };
+
+ struct ReadDirentsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::VectorView<uint8_t> dirents;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsReadDirentsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 ReadDirentsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t max_bytes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsReadDirentsRequestTable;
+ 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 = ReadDirentsResponse;
+ };
+
+ struct RewindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsRewindResponseTable;
+ 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 RewindRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::zx::handle token;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsGetTokenResponseTable;
+ 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 GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct RenameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsRenameResponseTable;
+ 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 RenameRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView src;
+ ::zx::handle dst_parent_token;
+ ::fidl::StringView dst;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsRenameRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = RenameResponse;
+ };
+
+ struct LinkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsLinkResponseTable;
+ 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 LinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView src;
+ ::zx::handle dst_parent_token;
+ ::fidl::StringView dst;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsLinkRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = LinkResponse;
+ };
+
+ struct WatchResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsWatchResponseTable;
+ 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 WatchRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t mask;
+ uint32_t options;
+ ::zx::channel watcher;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_FilesystemsWatchRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = WatchResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Open_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Unlink_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path);
+ ~Unlink_Impl() = default;
+ Unlink_Impl(Unlink_Impl&& other) = default;
+ Unlink_Impl& operator=(Unlink_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 ReadDirents_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadDirents_Impl(::zx::unowned_channel _client_end, uint64_t max_bytes);
+ ~ReadDirents_Impl() = default;
+ ReadDirents_Impl(ReadDirents_Impl&& other) = default;
+ ReadDirents_Impl& operator=(ReadDirents_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 Rewind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rewind_Impl(::zx::unowned_channel _client_end);
+ ~Rewind_Impl() = default;
+ Rewind_Impl(Rewind_Impl&& other) = default;
+ Rewind_Impl& operator=(Rewind_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 Rename_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+ ~Rename_Impl() = default;
+ Rename_Impl(Rename_Impl&& other) = default;
+ Rename_Impl& operator=(Rename_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 Link_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+ ~Link_Impl() = default;
+ Link_Impl(Link_Impl&& other) = default;
+ Link_Impl& operator=(Link_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 Watch_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Watch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
+ ~Watch_Impl() = default;
+ Watch_Impl(Watch_Impl&& other) = default;
+ Watch_Impl& operator=(Watch_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Open = Open_Impl;
+ using Unlink = Unlink_Impl<UnlinkResponse>;
+ using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
+ using Rewind = Rewind_Impl<RewindResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using Rename = Rename_Impl<RenameResponse>;
+ using Link = Link_Impl<LinkResponse>;
+ using Watch = Watch_Impl<WatchResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Open_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Unlink_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+ ~Unlink_Impl() = default;
+ Unlink_Impl(Unlink_Impl&& other) = default;
+ Unlink_Impl& operator=(Unlink_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 ReadDirents_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+ ~ReadDirents_Impl() = default;
+ ReadDirents_Impl(ReadDirents_Impl&& other) = default;
+ ReadDirents_Impl& operator=(ReadDirents_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 Rewind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rewind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Rewind_Impl() = default;
+ Rewind_Impl(Rewind_Impl&& other) = default;
+ Rewind_Impl& operator=(Rewind_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 Rename_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+ ~Rename_Impl() = default;
+ Rename_Impl(Rename_Impl&& other) = default;
+ Rename_Impl& operator=(Rename_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 Link_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+ ~Link_Impl() = default;
+ Link_Impl(Link_Impl&& other) = default;
+ Link_Impl& operator=(Link_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 Watch_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+ ~Watch_Impl() = default;
+ Watch_Impl(Watch_Impl&& other) = default;
+ Watch_Impl& operator=(Watch_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Open = Open_Impl;
+ using Unlink = Unlink_Impl<UnlinkResponse>;
+ using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
+ using Rewind = Rewind_Impl<RewindResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using Rename = Rename_Impl<RenameResponse>;
+ using Link = Link_Impl<LinkResponse>;
+ using Watch = Watch_Impl<WatchResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Request is heap-allocated.
+ ResultOf::Open Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Open Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Unlink Unlink(::fidl::StringView path);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Unlink Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::ReadDirents ReadDirents(uint64_t max_bytes);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadDirents ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Rewind Rewind();
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rewind Rewind(::fidl::BytePart _response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Rename Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rename Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Link Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Link Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Watch Watch(uint32_t mask, uint32_t options, ::zx::channel watcher);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Watch Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Request is heap-allocated.
+ static ResultOf::Open Open(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Open Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, uint64_t max_bytes);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Rewind Rewind(::zx::unowned_channel _client_end);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rewind Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Watch Watch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Watch Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ static ::fidl::internal::StatusAndError Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<UnlinkResponse> Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ static ::fidl::DecodeResult<ReadDirentsResponse> ReadDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ static ::fidl::DecodeResult<RewindResponse> Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<RenameResponse> Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<LinkResponse> Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ static ::fidl::DecodeResult<WatchResponse> Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Filesystems;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ using OpenCompleter = ::fidl::Completer<>;
+
+ virtual void Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object, OpenCompleter::Sync _completer) = 0;
+
+ class UnlinkCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<UnlinkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnlinkCompleter = ::fidl::Completer<UnlinkCompleterBase>;
+
+ virtual void Unlink(::fidl::StringView path, UnlinkCompleter::Sync _completer) = 0;
+
+ class ReadDirentsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents);
+ void Reply(::fidl::DecodedMessage<ReadDirentsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadDirentsCompleter = ::fidl::Completer<ReadDirentsCompleterBase>;
+
+ virtual void ReadDirents(uint64_t max_bytes, ReadDirentsCompleter::Sync _completer) = 0;
+
+ class RewindCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<RewindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RewindCompleter = ::fidl::Completer<RewindCompleterBase>;
+
+ virtual void Rewind(RewindCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::zx::handle token);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class RenameCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<RenameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RenameCompleter = ::fidl::Completer<RenameCompleterBase>;
+
+ virtual void Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, RenameCompleter::Sync _completer) = 0;
+
+ class LinkCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<LinkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LinkCompleter = ::fidl::Completer<LinkCompleterBase>;
+
+ virtual void Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, LinkCompleter::Sync _completer) = 0;
+
+ class WatchCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<WatchResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchCompleter = ::fidl::Completer<WatchCompleterBase>;
+
+ virtual void Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, WatchCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<Filesystems::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Filesystems::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<Filesystems::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Filesystems::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Filesystems::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<Filesystems::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Filesystems::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Filesystems::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<Filesystems::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<Filesystems::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<Filesystems::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<Filesystems::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<Filesystems::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<Filesystems::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<Filesystems::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<Filesystems::NodeSetFlagsResponse>& _msg);
+ static void OpenRequest(const ::fidl::DecodedMessage<Filesystems::OpenRequest>& _msg);
+ static void UnlinkRequest(const ::fidl::DecodedMessage<Filesystems::UnlinkRequest>& _msg);
+ static void UnlinkResponse(const ::fidl::DecodedMessage<Filesystems::UnlinkResponse>& _msg);
+ static void ReadDirentsRequest(const ::fidl::DecodedMessage<Filesystems::ReadDirentsRequest>& _msg);
+ static void ReadDirentsResponse(const ::fidl::DecodedMessage<Filesystems::ReadDirentsResponse>& _msg);
+ static void RewindRequest(const ::fidl::DecodedMessage<Filesystems::RewindRequest>& _msg);
+ static void RewindResponse(const ::fidl::DecodedMessage<Filesystems::RewindResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<Filesystems::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<Filesystems::GetTokenResponse>& _msg);
+ static void RenameRequest(const ::fidl::DecodedMessage<Filesystems::RenameRequest>& _msg);
+ static void RenameResponse(const ::fidl::DecodedMessage<Filesystems::RenameResponse>& _msg);
+ static void LinkRequest(const ::fidl::DecodedMessage<Filesystems::LinkRequest>& _msg);
+ static void LinkResponse(const ::fidl::DecodedMessage<Filesystems::LinkResponse>& _msg);
+ static void WatchRequest(const ::fidl::DecodedMessage<Filesystems::WatchRequest>& _msg);
+ static void WatchResponse(const ::fidl::DecodedMessage<Filesystems::WatchResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_fshost_AdminShutdownRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_AdminShutdownResponseTable;
+// Manages fshost lifecycle
+class Admin final {
+ Admin() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.fshost.Admin";
+
+ using ShutdownResponse = ::fidl::AnyZeroArgMessage;
+ using ShutdownRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Shutdown_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Shutdown_Impl(::zx::unowned_channel _client_end);
+ ~Shutdown_Impl() = default;
+ Shutdown_Impl(Shutdown_Impl&& other) = default;
+ Shutdown_Impl& operator=(Shutdown_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 Shutdown = Shutdown_Impl<ShutdownResponse>;
+ };
+
+ // 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 Shutdown_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Shutdown_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Shutdown_Impl() = default;
+ Shutdown_Impl(Shutdown_Impl&& other) = default;
+ Shutdown_Impl& operator=(Shutdown_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 Shutdown = Shutdown_Impl<ShutdownResponse>;
+ };
+
+ 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_; }
+
+ // Causes fshost to unmount all filesystems and exit. Fshost has
+ // successfully unmounted all filesystems when this function returns, and
+ // exits immediately after writing the response to this function.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Shutdown Shutdown();
+
+
+ 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:
+
+ // Causes fshost to unmount all filesystems and exit. Fshost has
+ // successfully unmounted all filesystems when this function returns, and
+ // exits immediately after writing the response to this function.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Shutdown Shutdown(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // Causes fshost to unmount all filesystems and exit. Fshost has
+ // successfully unmounted all filesystems when this function returns, and
+ // exits immediately after writing the response to this function.
+ static ::fidl::DecodeResult<ShutdownResponse> Shutdown(::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 = Admin;
+ using _Base = ::fidl::CompleterBase;
+
+ class ShutdownCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ShutdownCompleter = ::fidl::Completer<ShutdownCompleterBase>;
+
+ virtual void Shutdown(ShutdownCompleter::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 ShutdownRequest(const ::fidl::DecodedMessage<Admin::ShutdownRequest>& _msg);
+ static void ShutdownResponse(const ::fidl::DecodedMessage<Admin::ShutdownResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_fshost_RegistryRegisterFilesystemRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_fshost_RegistryRegisterFilesystemResponseTable;
+
+// Manages filesystems which wish to be globally exposed under the filesystem host.
+class Registry final {
+ Registry() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.fshost.Registry";
+
+ struct RegisterFilesystemResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_RegistryRegisterFilesystemResponseTable;
+ 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 RegisterFilesystemRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel public_export;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_fshost_RegistryRegisterFilesystemRequestTable;
+ 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 = RegisterFilesystemResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class RegisterFilesystem_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RegisterFilesystem_Impl(::zx::unowned_channel _client_end, ::zx::channel public_export);
+ ~RegisterFilesystem_Impl() = default;
+ RegisterFilesystem_Impl(RegisterFilesystem_Impl&& other) = default;
+ RegisterFilesystem_Impl& operator=(RegisterFilesystem_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 RegisterFilesystem = RegisterFilesystem_Impl<RegisterFilesystemResponse>;
+ };
+
+ // 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 RegisterFilesystem_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RegisterFilesystem_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel public_export, ::fidl::BytePart _response_buffer);
+ ~RegisterFilesystem_Impl() = default;
+ RegisterFilesystem_Impl(RegisterFilesystem_Impl&& other) = default;
+ RegisterFilesystem_Impl& operator=(RegisterFilesystem_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 RegisterFilesystem = RegisterFilesystem_Impl<RegisterFilesystemResponse>;
+ };
+
+ 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_; }
+
+ // Registers the output directory of a filesystem. These filesystems are
+ // exported from the fuchsia.fshost.Filesystems service, where they are
+ // be identified by an instance number (of the form "000", "001", etc).
+ //
+ // This directory is automatically de-registered from fuchsia.fshost.Filesystems
+ // if the server end of the connection is closed.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RegisterFilesystem RegisterFilesystem(::zx::channel public_export);
+
+ // Registers the output directory of a filesystem. These filesystems are
+ // exported from the fuchsia.fshost.Filesystems service, where they are
+ // be identified by an instance number (of the form "000", "001", etc).
+ //
+ // This directory is automatically de-registered from fuchsia.fshost.Filesystems
+ // if the server end of the connection is closed.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RegisterFilesystem RegisterFilesystem(::fidl::BytePart _request_buffer, ::zx::channel public_export, ::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:
+
+ // Registers the output directory of a filesystem. These filesystems are
+ // exported from the fuchsia.fshost.Filesystems service, where they are
+ // be identified by an instance number (of the form "000", "001", etc).
+ //
+ // This directory is automatically de-registered from fuchsia.fshost.Filesystems
+ // if the server end of the connection is closed.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RegisterFilesystem RegisterFilesystem(::zx::unowned_channel _client_end, ::zx::channel public_export);
+
+ // Registers the output directory of a filesystem. These filesystems are
+ // exported from the fuchsia.fshost.Filesystems service, where they are
+ // be identified by an instance number (of the form "000", "001", etc).
+ //
+ // This directory is automatically de-registered from fuchsia.fshost.Filesystems
+ // if the server end of the connection is closed.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RegisterFilesystem RegisterFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel public_export, ::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:
+
+ // Registers the output directory of a filesystem. These filesystems are
+ // exported from the fuchsia.fshost.Filesystems service, where they are
+ // be identified by an instance number (of the form "000", "001", etc).
+ //
+ // This directory is automatically de-registered from fuchsia.fshost.Filesystems
+ // if the server end of the connection is closed.
+ static ::fidl::DecodeResult<RegisterFilesystemResponse> RegisterFilesystem(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RegisterFilesystemRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Registry;
+ using _Base = ::fidl::CompleterBase;
+
+ class RegisterFilesystemCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<RegisterFilesystemResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RegisterFilesystemCompleter = ::fidl::Completer<RegisterFilesystemCompleterBase>;
+
+ virtual void RegisterFilesystem(::zx::channel public_export, RegisterFilesystemCompleter::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 RegisterFilesystemRequest(const ::fidl::DecodedMessage<Registry::RegisterFilesystemRequest>& _msg);
+ static void RegisterFilesystemResponse(const ::fidl::DecodedMessage<Registry::RegisterFilesystemResponse>& _msg);
+ };
+};
+
+} // namespace fshost
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::CloneRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::CloseResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::DescribeResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::OnOpenResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::SyncResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::GetAttrResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::SetAttrRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::SetAttrResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::OpenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::OpenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::OpenRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::OpenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::OpenRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::OpenRequest, mode) == 20);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::OpenRequest, path) == 24);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::OpenRequest, object) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::UnlinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::UnlinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::UnlinkRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::UnlinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::UnlinkRequest, path) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::UnlinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::UnlinkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::UnlinkResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::UnlinkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::UnlinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::ReadDirentsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::ReadDirentsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::ReadDirentsRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::ReadDirentsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::ReadDirentsRequest, max_bytes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::ReadDirentsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::ReadDirentsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::ReadDirentsResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::ReadDirentsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::ReadDirentsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::ReadDirentsResponse, dirents) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::RewindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::RewindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::RewindResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::RewindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::RewindResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::GetTokenResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::GetTokenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::GetTokenResponse, token) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::RenameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::RenameRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::RenameRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::RenameRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::RenameRequest, src) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::RenameRequest, dst_parent_token) == 32);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::RenameRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::RenameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::RenameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::RenameResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::RenameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::RenameResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::LinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::LinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::LinkRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::LinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::LinkRequest, src) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::LinkRequest, dst_parent_token) == 32);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::LinkRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::LinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::LinkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::LinkResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::LinkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::LinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::WatchRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::WatchRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::WatchRequest)
+ == ::llcpp::fuchsia::fshost::Filesystems::WatchRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::WatchRequest, mask) == 16);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::WatchRequest, options) == 20);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::WatchRequest, watcher) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Filesystems::WatchResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Filesystems::WatchResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Filesystems::WatchResponse)
+ == ::llcpp::fuchsia::fshost::Filesystems::WatchResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Filesystems::WatchResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Registry::RegisterFilesystemRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Registry::RegisterFilesystemRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Registry::RegisterFilesystemRequest)
+ == ::llcpp::fuchsia::fshost::Registry::RegisterFilesystemRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Registry::RegisterFilesystemRequest, public_export) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::fshost::Registry::RegisterFilesystemResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::fshost::Registry::RegisterFilesystemResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::fshost::Registry::RegisterFilesystemResponse)
+ == ::llcpp::fuchsia::fshost::Registry::RegisterFilesystemResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::fshost::Registry::RegisterFilesystemResponse, s) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-audio/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-audio/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..64c8778
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-audio/gen/llcpp/fidl.cc
@@ -0,0 +1,1804 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/audio/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace audio {
+
+::llcpp::fuchsia::hardware::audio::PlugState::Builder PlugState::Build() {
+ return PlugState::Builder();
+}
+
+auto ::llcpp::fuchsia::hardware::audio::PlugState::Builder::set_plugged(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::PlugState::Builder::set_plug_state_time(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::hardware::audio::RingBufferProperties::Builder RingBufferProperties::Build() {
+ return RingBufferProperties::Builder();
+}
+
+auto ::llcpp::fuchsia::hardware::audio::RingBufferProperties::Builder::set_external_delay(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::RingBufferProperties::Builder::set_fifo_depth(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::RingBufferProperties::Builder::set_clock_domain(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::RingBufferProperties::Builder::set_needs_cache_flush_or_invalidate(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetChannel_Ordinal = 0x6e14495500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetChannel_GenOrdinal = 0x51e1b0efe5849972lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_DeviceGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_DeviceGetChannelResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetChannel_Impl<Device::GetChannelResponse>::GetChannel_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChannelRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetChannelRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetChannel(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetChannel Device::SyncClient::GetChannel() {
+ return ResultOf::GetChannel(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetChannel Device::Call::GetChannel(::zx::unowned_channel _client_end) {
+ return ResultOf::GetChannel(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetChannel_Impl<Device::GetChannelResponse>::GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetChannelRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetChannelRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetChannel(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetChannel Device::SyncClient::GetChannel(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetChannel(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetChannel Device::Call::GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetChannel(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetChannelResponse> Device::InPlace::GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetChannelRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetChannelRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetChannelRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetChannelResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetChannelRequest, GetChannelResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetChannelResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetChannel_Ordinal:
+ case kDevice_GetChannel_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetChannelRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetChannel(
+ Interface::GetChannelCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetChannelCompleterBase::Reply(::zx::channel channel) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChannelResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetChannelResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetChannelResponse(
+ ::fidl::DecodedMessage<GetChannelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetChannelResponse::PrimarySize,
+ GetChannelResponse::PrimarySize)));
+ _response.channel = std::move(channel);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChannelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetChannelResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetChannelCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::channel channel) {
+ if (_buffer.capacity() < GetChannelResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetChannelResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetChannelResponse(
+ ::fidl::DecodedMessage<GetChannelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetChannelResponse::PrimarySize,
+ GetChannelResponse::PrimarySize)));
+ _response.channel = std::move(channel);
+ _buffer.set_actual(sizeof(GetChannelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetChannelResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetChannelCompleterBase::Reply(::fidl::DecodedMessage<GetChannelResponse> params) {
+ Device::SetTransactionHeaderFor::GetChannelResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetChannelRequest(const ::fidl::DecodedMessage<Device::GetChannelRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetChannelResponse(const ::fidl::DecodedMessage<Device::GetChannelResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+::llcpp::fuchsia::hardware::audio::SupportedFormats::Builder SupportedFormats::Build() {
+ return SupportedFormats::Builder();
+}
+
+auto ::llcpp::fuchsia::hardware::audio::SupportedFormats::Builder::set_pcm_supported_formats(::llcpp::fuchsia::hardware::audio::PcmSupportedFormats* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::hardware::audio::Format::Builder Format::Build() {
+ return Format::Builder();
+}
+
+auto ::llcpp::fuchsia::hardware::audio::Format::Builder::set_pcm_format(::llcpp::fuchsia::hardware::audio::PcmFormat* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::hardware::audio::StreamProperties::Builder StreamProperties::Build() {
+ return StreamProperties::Builder();
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_unique_id(::fidl::Array<uint8_t, 16>* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_is_input(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_can_mute(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_can_agc(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_min_gain_db(float* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_max_gain_db(float* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[6 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 6) {
+ max_ordinal_ = 6;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_gain_step_db(float* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[7 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 7) {
+ max_ordinal_ = 7;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_plug_detect_capabilities(::llcpp::fuchsia::hardware::audio::PlugDetectCapabilities* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[8 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 8) {
+ max_ordinal_ = 8;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_manufacturer(::fidl::StringView* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[9 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 9) {
+ max_ordinal_ = 9;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::StreamProperties::Builder::set_product(::fidl::StringView* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[10 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 10) {
+ max_ordinal_ = 10;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(RingBuffer_GetVmo_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(RingBuffer_GetVmo_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(RingBuffer_GetVmo_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_GetProperties_Ordinal = 0x72b8bf3600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_GetProperties_GenOrdinal = 0x12947f061a8fe1lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferGetPropertiesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferGetPropertiesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_WatchClockRecoveryPositionInfo_Ordinal = 0x428b0f8300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_WatchClockRecoveryPositionInfo_GenOrdinal = 0x694d5b898a4167e5lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferWatchClockRecoveryPositionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferWatchClockRecoveryPositionInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_GetVmo_Ordinal = 0x330599f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_GetVmo_GenOrdinal = 0x44c8f4f5680e853alu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferGetVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferGetVmoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_Start_Ordinal = 0x6028425000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_Start_GenOrdinal = 0x5dd780a769a8892dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferStartResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_Stop_Ordinal = 0x25c2cd8800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kRingBuffer_Stop_GenOrdinal = 0x49a73d9cf1d4e110lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferStopResponseTable;
+
+} // namespace
+template <>
+RingBuffer::ResultOf::GetProperties_Impl<RingBuffer::GetPropertiesResponse>::GetProperties_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPropertiesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPropertiesRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPropertiesRequest));
+ ::fidl::DecodedMessage<GetPropertiesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ RingBuffer::InPlace::GetProperties(std::move(_client_end), Super::response_buffer()));
+}
+
+RingBuffer::ResultOf::GetProperties RingBuffer::SyncClient::GetProperties() {
+ return ResultOf::GetProperties(::zx::unowned_channel(this->channel_));
+}
+
+RingBuffer::ResultOf::GetProperties RingBuffer::Call::GetProperties(::zx::unowned_channel _client_end) {
+ return ResultOf::GetProperties(std::move(_client_end));
+}
+
+template <>
+RingBuffer::UnownedResultOf::GetProperties_Impl<RingBuffer::GetPropertiesResponse>::GetProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPropertiesRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPropertiesRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPropertiesRequest));
+ ::fidl::DecodedMessage<GetPropertiesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ RingBuffer::InPlace::GetProperties(std::move(_client_end), std::move(_response_buffer)));
+}
+
+RingBuffer::UnownedResultOf::GetProperties RingBuffer::SyncClient::GetProperties(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetProperties(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+RingBuffer::UnownedResultOf::GetProperties RingBuffer::Call::GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetProperties(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<RingBuffer::GetPropertiesResponse> RingBuffer::InPlace::GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPropertiesRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPropertiesRequest> params(std::move(_request_buffer));
+ RingBuffer::SetTransactionHeaderFor::GetPropertiesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::GetPropertiesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPropertiesRequest, GetPropertiesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::GetPropertiesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+RingBuffer::ResultOf::WatchClockRecoveryPositionInfo_Impl<RingBuffer::WatchClockRecoveryPositionInfoResponse>::WatchClockRecoveryPositionInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchClockRecoveryPositionInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchClockRecoveryPositionInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchClockRecoveryPositionInfoRequest));
+ ::fidl::DecodedMessage<WatchClockRecoveryPositionInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ RingBuffer::InPlace::WatchClockRecoveryPositionInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+RingBuffer::ResultOf::WatchClockRecoveryPositionInfo RingBuffer::SyncClient::WatchClockRecoveryPositionInfo() {
+ return ResultOf::WatchClockRecoveryPositionInfo(::zx::unowned_channel(this->channel_));
+}
+
+RingBuffer::ResultOf::WatchClockRecoveryPositionInfo RingBuffer::Call::WatchClockRecoveryPositionInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::WatchClockRecoveryPositionInfo(std::move(_client_end));
+}
+
+template <>
+RingBuffer::UnownedResultOf::WatchClockRecoveryPositionInfo_Impl<RingBuffer::WatchClockRecoveryPositionInfoResponse>::WatchClockRecoveryPositionInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WatchClockRecoveryPositionInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WatchClockRecoveryPositionInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WatchClockRecoveryPositionInfoRequest));
+ ::fidl::DecodedMessage<WatchClockRecoveryPositionInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ RingBuffer::InPlace::WatchClockRecoveryPositionInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+RingBuffer::UnownedResultOf::WatchClockRecoveryPositionInfo RingBuffer::SyncClient::WatchClockRecoveryPositionInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchClockRecoveryPositionInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+RingBuffer::UnownedResultOf::WatchClockRecoveryPositionInfo RingBuffer::Call::WatchClockRecoveryPositionInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchClockRecoveryPositionInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<RingBuffer::WatchClockRecoveryPositionInfoResponse> RingBuffer::InPlace::WatchClockRecoveryPositionInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WatchClockRecoveryPositionInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WatchClockRecoveryPositionInfoRequest> params(std::move(_request_buffer));
+ RingBuffer::SetTransactionHeaderFor::WatchClockRecoveryPositionInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::WatchClockRecoveryPositionInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchClockRecoveryPositionInfoRequest, WatchClockRecoveryPositionInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::WatchClockRecoveryPositionInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+RingBuffer::ResultOf::GetVmo_Impl<RingBuffer::GetVmoResponse>::GetVmo_Impl(::zx::unowned_channel _client_end, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetVmoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetVmoRequest*>(_write_bytes);
+ _request.min_frames = std::move(min_frames);
+ _request.clock_recovery_notifications_per_ring = std::move(clock_recovery_notifications_per_ring);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetVmoRequest));
+ ::fidl::DecodedMessage<GetVmoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ RingBuffer::InPlace::GetVmo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+RingBuffer::ResultOf::GetVmo RingBuffer::SyncClient::GetVmo(uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring) {
+ return ResultOf::GetVmo(::zx::unowned_channel(this->channel_), std::move(min_frames), std::move(clock_recovery_notifications_per_ring));
+}
+
+RingBuffer::ResultOf::GetVmo RingBuffer::Call::GetVmo(::zx::unowned_channel _client_end, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring) {
+ return ResultOf::GetVmo(std::move(_client_end), std::move(min_frames), std::move(clock_recovery_notifications_per_ring));
+}
+
+template <>
+RingBuffer::UnownedResultOf::GetVmo_Impl<RingBuffer::GetVmoResponse>::GetVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetVmoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetVmoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetVmoRequest*>(_request_buffer.data());
+ _request.min_frames = std::move(min_frames);
+ _request.clock_recovery_notifications_per_ring = std::move(clock_recovery_notifications_per_ring);
+ _request_buffer.set_actual(sizeof(GetVmoRequest));
+ ::fidl::DecodedMessage<GetVmoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ RingBuffer::InPlace::GetVmo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+RingBuffer::UnownedResultOf::GetVmo RingBuffer::SyncClient::GetVmo(::fidl::BytePart _request_buffer, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetVmo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(min_frames), std::move(clock_recovery_notifications_per_ring), std::move(_response_buffer));
+}
+
+RingBuffer::UnownedResultOf::GetVmo RingBuffer::Call::GetVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetVmo(std::move(_client_end), std::move(_request_buffer), std::move(min_frames), std::move(clock_recovery_notifications_per_ring), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<RingBuffer::GetVmoResponse> RingBuffer::InPlace::GetVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetVmoRequest> params, ::fidl::BytePart response_buffer) {
+ RingBuffer::SetTransactionHeaderFor::GetVmoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::GetVmoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetVmoRequest, GetVmoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::GetVmoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+RingBuffer::ResultOf::Start_Impl<RingBuffer::StartResponse>::Start_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StartRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartRequest));
+ ::fidl::DecodedMessage<StartRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ RingBuffer::InPlace::Start(std::move(_client_end), Super::response_buffer()));
+}
+
+RingBuffer::ResultOf::Start RingBuffer::SyncClient::Start() {
+ return ResultOf::Start(::zx::unowned_channel(this->channel_));
+}
+
+RingBuffer::ResultOf::Start RingBuffer::Call::Start(::zx::unowned_channel _client_end) {
+ return ResultOf::Start(std::move(_client_end));
+}
+
+template <>
+RingBuffer::UnownedResultOf::Start_Impl<RingBuffer::StartResponse>::Start_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(StartRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, StartRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(StartRequest));
+ ::fidl::DecodedMessage<StartRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ RingBuffer::InPlace::Start(std::move(_client_end), std::move(_response_buffer)));
+}
+
+RingBuffer::UnownedResultOf::Start RingBuffer::SyncClient::Start(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Start(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+RingBuffer::UnownedResultOf::Start RingBuffer::Call::Start(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Start(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<RingBuffer::StartResponse> RingBuffer::InPlace::Start(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(StartRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<StartRequest> params(std::move(_request_buffer));
+ RingBuffer::SetTransactionHeaderFor::StartRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::StartResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StartRequest, StartResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::StartResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+RingBuffer::ResultOf::Stop_Impl<RingBuffer::StopResponse>::Stop_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StopRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StopRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StopRequest));
+ ::fidl::DecodedMessage<StopRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ RingBuffer::InPlace::Stop(std::move(_client_end), Super::response_buffer()));
+}
+
+RingBuffer::ResultOf::Stop RingBuffer::SyncClient::Stop() {
+ return ResultOf::Stop(::zx::unowned_channel(this->channel_));
+}
+
+RingBuffer::ResultOf::Stop RingBuffer::Call::Stop(::zx::unowned_channel _client_end) {
+ return ResultOf::Stop(std::move(_client_end));
+}
+
+::fidl::DecodeResult<RingBuffer::StopResponse> RingBuffer::InPlace::Stop(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(StopRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<StopRequest> params(std::move(_request_buffer));
+ RingBuffer::SetTransactionHeaderFor::StopRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::StopResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StopRequest, StopResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<RingBuffer::StopResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool RingBuffer::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kRingBuffer_GetProperties_Ordinal:
+ case kRingBuffer_GetProperties_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPropertiesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetProperties(
+ Interface::GetPropertiesCompleter::Sync(txn));
+ return true;
+ }
+ case kRingBuffer_WatchClockRecoveryPositionInfo_Ordinal:
+ case kRingBuffer_WatchClockRecoveryPositionInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchClockRecoveryPositionInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WatchClockRecoveryPositionInfo(
+ Interface::WatchClockRecoveryPositionInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kRingBuffer_GetVmo_Ordinal:
+ case kRingBuffer_GetVmo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetVmoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetVmo(std::move(message->min_frames), std::move(message->clock_recovery_notifications_per_ring),
+ Interface::GetVmoCompleter::Sync(txn));
+ return true;
+ }
+ case kRingBuffer_Start_Ordinal:
+ case kRingBuffer_Start_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StartRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Start(
+ Interface::StartCompleter::Sync(txn));
+ return true;
+ }
+ case kRingBuffer_Stop_Ordinal:
+ case kRingBuffer_Stop_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StopRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Stop(
+ Interface::StopCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool RingBuffer::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void RingBuffer::Interface::GetPropertiesCompleterBase::Reply(::llcpp::fuchsia::hardware::audio::RingBufferProperties properties) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPropertiesResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetPropertiesResponse _response = {};
+ RingBuffer::SetTransactionHeaderFor::GetPropertiesResponse(
+ ::fidl::DecodedMessage<GetPropertiesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPropertiesResponse::PrimarySize,
+ GetPropertiesResponse::PrimarySize)));
+ _response.properties = std::move(properties);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void RingBuffer::Interface::GetPropertiesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::RingBufferProperties properties) {
+ if (_buffer.capacity() < GetPropertiesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPropertiesResponse _response = {};
+ RingBuffer::SetTransactionHeaderFor::GetPropertiesResponse(
+ ::fidl::DecodedMessage<GetPropertiesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPropertiesResponse::PrimarySize,
+ GetPropertiesResponse::PrimarySize)));
+ _response.properties = std::move(properties);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void RingBuffer::Interface::GetPropertiesCompleterBase::Reply(::fidl::DecodedMessage<GetPropertiesResponse> params) {
+ RingBuffer::SetTransactionHeaderFor::GetPropertiesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void RingBuffer::Interface::WatchClockRecoveryPositionInfoCompleterBase::Reply(::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo position_info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchClockRecoveryPositionInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WatchClockRecoveryPositionInfoResponse*>(_write_bytes);
+ RingBuffer::SetTransactionHeaderFor::WatchClockRecoveryPositionInfoResponse(
+ ::fidl::DecodedMessage<WatchClockRecoveryPositionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchClockRecoveryPositionInfoResponse::PrimarySize,
+ WatchClockRecoveryPositionInfoResponse::PrimarySize)));
+ _response.position_info = std::move(position_info);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchClockRecoveryPositionInfoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchClockRecoveryPositionInfoResponse>(std::move(_response_bytes)));
+}
+
+void RingBuffer::Interface::WatchClockRecoveryPositionInfoCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo position_info) {
+ if (_buffer.capacity() < WatchClockRecoveryPositionInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WatchClockRecoveryPositionInfoResponse*>(_buffer.data());
+ RingBuffer::SetTransactionHeaderFor::WatchClockRecoveryPositionInfoResponse(
+ ::fidl::DecodedMessage<WatchClockRecoveryPositionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchClockRecoveryPositionInfoResponse::PrimarySize,
+ WatchClockRecoveryPositionInfoResponse::PrimarySize)));
+ _response.position_info = std::move(position_info);
+ _buffer.set_actual(sizeof(WatchClockRecoveryPositionInfoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchClockRecoveryPositionInfoResponse>(std::move(_buffer)));
+}
+
+void RingBuffer::Interface::WatchClockRecoveryPositionInfoCompleterBase::Reply(::fidl::DecodedMessage<WatchClockRecoveryPositionInfoResponse> params) {
+ RingBuffer::SetTransactionHeaderFor::WatchClockRecoveryPositionInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void RingBuffer::Interface::GetVmoCompleterBase::Reply(::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetVmoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetVmoResponse _response = {};
+ RingBuffer::SetTransactionHeaderFor::GetVmoResponse(
+ ::fidl::DecodedMessage<GetVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetVmoResponse::PrimarySize,
+ GetVmoResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void RingBuffer::Interface::GetVmoCompleterBase::ReplySuccess(uint32_t num_frames, ::zx::vmo ring_buffer) {
+ RingBuffer_GetVmo_Response response;
+ response.num_frames = std::move(num_frames);
+ response.ring_buffer = std::move(ring_buffer);
+
+ Reply(RingBuffer_GetVmo_Result::WithResponse(&response));
+}
+void RingBuffer::Interface::GetVmoCompleterBase::ReplyError(GetVmoError error) {
+ Reply(RingBuffer_GetVmo_Result::WithErr(&error));
+}
+
+void RingBuffer::Interface::GetVmoCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Result result) {
+ if (_buffer.capacity() < GetVmoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetVmoResponse _response = {};
+ RingBuffer::SetTransactionHeaderFor::GetVmoResponse(
+ ::fidl::DecodedMessage<GetVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetVmoResponse::PrimarySize,
+ GetVmoResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void RingBuffer::Interface::GetVmoCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint32_t num_frames, ::zx::vmo ring_buffer) {
+ RingBuffer_GetVmo_Response response;
+ response.num_frames = std::move(num_frames);
+ response.ring_buffer = std::move(ring_buffer);
+
+ Reply(std::move(_buffer), RingBuffer_GetVmo_Result::WithResponse(&response));
+}
+
+void RingBuffer::Interface::GetVmoCompleterBase::Reply(::fidl::DecodedMessage<GetVmoResponse> params) {
+ RingBuffer::SetTransactionHeaderFor::GetVmoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void RingBuffer::Interface::StartCompleterBase::Reply(int64_t start_time) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StartResponse*>(_write_bytes);
+ RingBuffer::SetTransactionHeaderFor::StartResponse(
+ ::fidl::DecodedMessage<StartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartResponse::PrimarySize,
+ StartResponse::PrimarySize)));
+ _response.start_time = std::move(start_time);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartResponse>(std::move(_response_bytes)));
+}
+
+void RingBuffer::Interface::StartCompleterBase::Reply(::fidl::BytePart _buffer, int64_t start_time) {
+ if (_buffer.capacity() < StartResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<StartResponse*>(_buffer.data());
+ RingBuffer::SetTransactionHeaderFor::StartResponse(
+ ::fidl::DecodedMessage<StartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartResponse::PrimarySize,
+ StartResponse::PrimarySize)));
+ _response.start_time = std::move(start_time);
+ _buffer.set_actual(sizeof(StartResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartResponse>(std::move(_buffer)));
+}
+
+void RingBuffer::Interface::StartCompleterBase::Reply(::fidl::DecodedMessage<StartResponse> params) {
+ RingBuffer::SetTransactionHeaderFor::StartResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void RingBuffer::Interface::StopCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StopResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StopResponse*>(_write_bytes);
+ RingBuffer::SetTransactionHeaderFor::StopResponse(
+ ::fidl::DecodedMessage<StopResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StopResponse::PrimarySize,
+ StopResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StopResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StopResponse>(std::move(_response_bytes)));
+}
+
+
+
+void RingBuffer::SetTransactionHeaderFor::GetPropertiesRequest(const ::fidl::DecodedMessage<RingBuffer::GetPropertiesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_GetProperties_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void RingBuffer::SetTransactionHeaderFor::GetPropertiesResponse(const ::fidl::DecodedMessage<RingBuffer::GetPropertiesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_GetProperties_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void RingBuffer::SetTransactionHeaderFor::WatchClockRecoveryPositionInfoRequest(const ::fidl::DecodedMessage<RingBuffer::WatchClockRecoveryPositionInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_WatchClockRecoveryPositionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void RingBuffer::SetTransactionHeaderFor::WatchClockRecoveryPositionInfoResponse(const ::fidl::DecodedMessage<RingBuffer::WatchClockRecoveryPositionInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_WatchClockRecoveryPositionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void RingBuffer::SetTransactionHeaderFor::GetVmoRequest(const ::fidl::DecodedMessage<RingBuffer::GetVmoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_GetVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void RingBuffer::SetTransactionHeaderFor::GetVmoResponse(const ::fidl::DecodedMessage<RingBuffer::GetVmoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_GetVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void RingBuffer::SetTransactionHeaderFor::StartRequest(const ::fidl::DecodedMessage<RingBuffer::StartRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_Start_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void RingBuffer::SetTransactionHeaderFor::StartResponse(const ::fidl::DecodedMessage<RingBuffer::StartResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_Start_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void RingBuffer::SetTransactionHeaderFor::StopRequest(const ::fidl::DecodedMessage<RingBuffer::StopRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_Stop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void RingBuffer::SetTransactionHeaderFor::StopResponse(const ::fidl::DecodedMessage<RingBuffer::StopResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kRingBuffer_Stop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+::llcpp::fuchsia::hardware::audio::GainState::Builder GainState::Build() {
+ return GainState::Builder();
+}
+
+auto ::llcpp::fuchsia::hardware::audio::GainState::Builder::set_muted(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::GainState::Builder::set_agc_enabled(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::audio::GainState::Builder::set_gain_db(float* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_GetProperties_Ordinal = 0x64e8e22600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_GetProperties_GenOrdinal = 0x7d89c02f3e2d3c01lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigGetPropertiesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigGetPropertiesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_GetSupportedFormats_Ordinal = 0x436ffebd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_GetSupportedFormats_GenOrdinal = 0x448efa7850cafe7elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigGetSupportedFormatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigGetSupportedFormatsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_CreateRingBuffer_Ordinal = 0x2f12bd3800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_CreateRingBuffer_GenOrdinal = 0x2afb19dd13faa1balu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigCreateRingBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigCreateRingBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_WatchGainState_Ordinal = 0x1e82e2b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_WatchGainState_GenOrdinal = 0x4772506136ab65c1lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigWatchGainStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigWatchGainStateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_SetGain_Ordinal = 0x7104625900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_SetGain_GenOrdinal = 0x3943b41498c6a384lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigSetGainRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigSetGainResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_WatchPlugState_Ordinal = 0x3174894d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamConfig_WatchPlugState_GenOrdinal = 0x497345a6f048b2a6lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigWatchPlugStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigWatchPlugStateResponseTable;
+
+} // namespace
+template <>
+StreamConfig::ResultOf::GetProperties_Impl<StreamConfig::GetPropertiesResponse>::GetProperties_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPropertiesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPropertiesRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPropertiesRequest));
+ ::fidl::DecodedMessage<GetPropertiesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamConfig::InPlace::GetProperties(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamConfig::ResultOf::GetProperties StreamConfig::SyncClient::GetProperties() {
+ return ResultOf::GetProperties(::zx::unowned_channel(this->channel_));
+}
+
+StreamConfig::ResultOf::GetProperties StreamConfig::Call::GetProperties(::zx::unowned_channel _client_end) {
+ return ResultOf::GetProperties(std::move(_client_end));
+}
+
+template <>
+StreamConfig::UnownedResultOf::GetProperties_Impl<StreamConfig::GetPropertiesResponse>::GetProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPropertiesRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPropertiesRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPropertiesRequest));
+ ::fidl::DecodedMessage<GetPropertiesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamConfig::InPlace::GetProperties(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamConfig::UnownedResultOf::GetProperties StreamConfig::SyncClient::GetProperties(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetProperties(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamConfig::UnownedResultOf::GetProperties StreamConfig::Call::GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetProperties(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamConfig::GetPropertiesResponse> StreamConfig::InPlace::GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPropertiesRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPropertiesRequest> params(std::move(_request_buffer));
+ StreamConfig::SetTransactionHeaderFor::GetPropertiesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamConfig::GetPropertiesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPropertiesRequest, GetPropertiesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamConfig::GetPropertiesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamConfig::ResultOf::GetSupportedFormats_Impl<StreamConfig::GetSupportedFormatsResponse>::GetSupportedFormats_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSupportedFormatsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSupportedFormatsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSupportedFormatsRequest));
+ ::fidl::DecodedMessage<GetSupportedFormatsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamConfig::InPlace::GetSupportedFormats(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamConfig::ResultOf::GetSupportedFormats StreamConfig::SyncClient::GetSupportedFormats() {
+ return ResultOf::GetSupportedFormats(::zx::unowned_channel(this->channel_));
+}
+
+StreamConfig::ResultOf::GetSupportedFormats StreamConfig::Call::GetSupportedFormats(::zx::unowned_channel _client_end) {
+ return ResultOf::GetSupportedFormats(std::move(_client_end));
+}
+
+template <>
+StreamConfig::UnownedResultOf::GetSupportedFormats_Impl<StreamConfig::GetSupportedFormatsResponse>::GetSupportedFormats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetSupportedFormatsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetSupportedFormatsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetSupportedFormatsRequest));
+ ::fidl::DecodedMessage<GetSupportedFormatsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamConfig::InPlace::GetSupportedFormats(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamConfig::UnownedResultOf::GetSupportedFormats StreamConfig::SyncClient::GetSupportedFormats(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSupportedFormats(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamConfig::UnownedResultOf::GetSupportedFormats StreamConfig::Call::GetSupportedFormats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSupportedFormats(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamConfig::GetSupportedFormatsResponse> StreamConfig::InPlace::GetSupportedFormats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetSupportedFormatsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetSupportedFormatsRequest> params(std::move(_request_buffer));
+ StreamConfig::SetTransactionHeaderFor::GetSupportedFormatsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamConfig::GetSupportedFormatsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSupportedFormatsRequest, GetSupportedFormatsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamConfig::GetSupportedFormatsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+StreamConfig::ResultOf::CreateRingBuffer_Impl::CreateRingBuffer_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateRingBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ CreateRingBufferRequest _request = {};
+ _request.format = std::move(format);
+ _request.ring_buffer = std::move(ring_buffer);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CreateRingBufferRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ StreamConfig::InPlace::CreateRingBuffer(std::move(_client_end), std::move(_decoded_request)));
+}
+
+StreamConfig::ResultOf::CreateRingBuffer StreamConfig::SyncClient::CreateRingBuffer(::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer) {
+ return ResultOf::CreateRingBuffer(::zx::unowned_channel(this->channel_), std::move(format), std::move(ring_buffer));
+}
+
+StreamConfig::ResultOf::CreateRingBuffer StreamConfig::Call::CreateRingBuffer(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer) {
+ return ResultOf::CreateRingBuffer(std::move(_client_end), std::move(format), std::move(ring_buffer));
+}
+
+
+StreamConfig::UnownedResultOf::CreateRingBuffer_Impl::CreateRingBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer) {
+ if (_request_buffer.capacity() < CreateRingBufferRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ CreateRingBufferRequest _request = {};
+ _request.format = std::move(format);
+ _request.ring_buffer = std::move(ring_buffer);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CreateRingBufferRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ StreamConfig::InPlace::CreateRingBuffer(std::move(_client_end), std::move(_decoded_request)));
+}
+
+StreamConfig::UnownedResultOf::CreateRingBuffer StreamConfig::SyncClient::CreateRingBuffer(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer) {
+ return UnownedResultOf::CreateRingBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(format), std::move(ring_buffer));
+}
+
+StreamConfig::UnownedResultOf::CreateRingBuffer StreamConfig::Call::CreateRingBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer) {
+ return UnownedResultOf::CreateRingBuffer(std::move(_client_end), std::move(_request_buffer), std::move(format), std::move(ring_buffer));
+}
+
+::fidl::internal::StatusAndError StreamConfig::InPlace::CreateRingBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateRingBufferRequest> params) {
+ StreamConfig::SetTransactionHeaderFor::CreateRingBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+StreamConfig::ResultOf::WatchGainState_Impl<StreamConfig::WatchGainStateResponse>::WatchGainState_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchGainStateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchGainStateRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchGainStateRequest));
+ ::fidl::DecodedMessage<WatchGainStateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamConfig::InPlace::WatchGainState(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamConfig::ResultOf::WatchGainState StreamConfig::SyncClient::WatchGainState() {
+ return ResultOf::WatchGainState(::zx::unowned_channel(this->channel_));
+}
+
+StreamConfig::ResultOf::WatchGainState StreamConfig::Call::WatchGainState(::zx::unowned_channel _client_end) {
+ return ResultOf::WatchGainState(std::move(_client_end));
+}
+
+template <>
+StreamConfig::UnownedResultOf::WatchGainState_Impl<StreamConfig::WatchGainStateResponse>::WatchGainState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WatchGainStateRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WatchGainStateRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WatchGainStateRequest));
+ ::fidl::DecodedMessage<WatchGainStateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamConfig::InPlace::WatchGainState(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamConfig::UnownedResultOf::WatchGainState StreamConfig::SyncClient::WatchGainState(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchGainState(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamConfig::UnownedResultOf::WatchGainState StreamConfig::Call::WatchGainState(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchGainState(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamConfig::WatchGainStateResponse> StreamConfig::InPlace::WatchGainState(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WatchGainStateRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WatchGainStateRequest> params(std::move(_request_buffer));
+ StreamConfig::SetTransactionHeaderFor::WatchGainStateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamConfig::WatchGainStateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchGainStateRequest, WatchGainStateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamConfig::WatchGainStateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+StreamConfig::ResultOf::SetGain_Impl::SetGain_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::audio::GainState target_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetGainRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ SetGainRequest _request = {};
+ _request.target_state = std::move(target_state);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetGainRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ StreamConfig::InPlace::SetGain(std::move(_client_end), std::move(_decoded_request)));
+}
+
+StreamConfig::ResultOf::SetGain StreamConfig::SyncClient::SetGain(::llcpp::fuchsia::hardware::audio::GainState target_state) {
+ return ResultOf::SetGain(::zx::unowned_channel(this->channel_), std::move(target_state));
+}
+
+StreamConfig::ResultOf::SetGain StreamConfig::Call::SetGain(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::audio::GainState target_state) {
+ return ResultOf::SetGain(std::move(_client_end), std::move(target_state));
+}
+
+
+StreamConfig::UnownedResultOf::SetGain_Impl::SetGain_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::GainState target_state) {
+ if (_request_buffer.capacity() < SetGainRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ SetGainRequest _request = {};
+ _request.target_state = std::move(target_state);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetGainRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ StreamConfig::InPlace::SetGain(std::move(_client_end), std::move(_decoded_request)));
+}
+
+StreamConfig::UnownedResultOf::SetGain StreamConfig::SyncClient::SetGain(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::GainState target_state) {
+ return UnownedResultOf::SetGain(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(target_state));
+}
+
+StreamConfig::UnownedResultOf::SetGain StreamConfig::Call::SetGain(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::GainState target_state) {
+ return UnownedResultOf::SetGain(std::move(_client_end), std::move(_request_buffer), std::move(target_state));
+}
+
+::fidl::internal::StatusAndError StreamConfig::InPlace::SetGain(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetGainRequest> params) {
+ StreamConfig::SetTransactionHeaderFor::SetGainRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+StreamConfig::ResultOf::WatchPlugState_Impl<StreamConfig::WatchPlugStateResponse>::WatchPlugState_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchPlugStateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchPlugStateRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchPlugStateRequest));
+ ::fidl::DecodedMessage<WatchPlugStateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamConfig::InPlace::WatchPlugState(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamConfig::ResultOf::WatchPlugState StreamConfig::SyncClient::WatchPlugState() {
+ return ResultOf::WatchPlugState(::zx::unowned_channel(this->channel_));
+}
+
+StreamConfig::ResultOf::WatchPlugState StreamConfig::Call::WatchPlugState(::zx::unowned_channel _client_end) {
+ return ResultOf::WatchPlugState(std::move(_client_end));
+}
+
+template <>
+StreamConfig::UnownedResultOf::WatchPlugState_Impl<StreamConfig::WatchPlugStateResponse>::WatchPlugState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WatchPlugStateRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WatchPlugStateRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WatchPlugStateRequest));
+ ::fidl::DecodedMessage<WatchPlugStateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamConfig::InPlace::WatchPlugState(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamConfig::UnownedResultOf::WatchPlugState StreamConfig::SyncClient::WatchPlugState(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchPlugState(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamConfig::UnownedResultOf::WatchPlugState StreamConfig::Call::WatchPlugState(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchPlugState(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamConfig::WatchPlugStateResponse> StreamConfig::InPlace::WatchPlugState(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WatchPlugStateRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WatchPlugStateRequest> params(std::move(_request_buffer));
+ StreamConfig::SetTransactionHeaderFor::WatchPlugStateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamConfig::WatchPlugStateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchPlugStateRequest, WatchPlugStateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamConfig::WatchPlugStateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool StreamConfig::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kStreamConfig_GetProperties_Ordinal:
+ case kStreamConfig_GetProperties_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPropertiesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetProperties(
+ Interface::GetPropertiesCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamConfig_GetSupportedFormats_Ordinal:
+ case kStreamConfig_GetSupportedFormats_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSupportedFormatsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetSupportedFormats(
+ Interface::GetSupportedFormatsCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamConfig_CreateRingBuffer_Ordinal:
+ case kStreamConfig_CreateRingBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateRingBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateRingBuffer(std::move(message->format), std::move(message->ring_buffer),
+ Interface::CreateRingBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamConfig_WatchGainState_Ordinal:
+ case kStreamConfig_WatchGainState_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchGainStateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WatchGainState(
+ Interface::WatchGainStateCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamConfig_SetGain_Ordinal:
+ case kStreamConfig_SetGain_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetGainRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetGain(std::move(message->target_state),
+ Interface::SetGainCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamConfig_WatchPlugState_Ordinal:
+ case kStreamConfig_WatchPlugState_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchPlugStateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WatchPlugState(
+ Interface::WatchPlugStateCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool StreamConfig::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void StreamConfig::Interface::GetPropertiesCompleterBase::Reply(::llcpp::fuchsia::hardware::audio::StreamProperties properties) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPropertiesResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetPropertiesResponse _response = {};
+ StreamConfig::SetTransactionHeaderFor::GetPropertiesResponse(
+ ::fidl::DecodedMessage<GetPropertiesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPropertiesResponse::PrimarySize,
+ GetPropertiesResponse::PrimarySize)));
+ _response.properties = std::move(properties);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamConfig::Interface::GetPropertiesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::StreamProperties properties) {
+ if (_buffer.capacity() < GetPropertiesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPropertiesResponse _response = {};
+ StreamConfig::SetTransactionHeaderFor::GetPropertiesResponse(
+ ::fidl::DecodedMessage<GetPropertiesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPropertiesResponse::PrimarySize,
+ GetPropertiesResponse::PrimarySize)));
+ _response.properties = std::move(properties);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamConfig::Interface::GetPropertiesCompleterBase::Reply(::fidl::DecodedMessage<GetPropertiesResponse> params) {
+ StreamConfig::SetTransactionHeaderFor::GetPropertiesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamConfig::Interface::GetSupportedFormatsCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::hardware::audio::SupportedFormats> supported_formats) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSupportedFormatsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetSupportedFormatsResponse _response = {};
+ StreamConfig::SetTransactionHeaderFor::GetSupportedFormatsResponse(
+ ::fidl::DecodedMessage<GetSupportedFormatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSupportedFormatsResponse::PrimarySize,
+ GetSupportedFormatsResponse::PrimarySize)));
+ _response.supported_formats = std::move(supported_formats);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamConfig::Interface::GetSupportedFormatsCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::hardware::audio::SupportedFormats> supported_formats) {
+ if (_buffer.capacity() < GetSupportedFormatsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSupportedFormatsResponse _response = {};
+ StreamConfig::SetTransactionHeaderFor::GetSupportedFormatsResponse(
+ ::fidl::DecodedMessage<GetSupportedFormatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSupportedFormatsResponse::PrimarySize,
+ GetSupportedFormatsResponse::PrimarySize)));
+ _response.supported_formats = std::move(supported_formats);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamConfig::Interface::GetSupportedFormatsCompleterBase::Reply(::fidl::DecodedMessage<GetSupportedFormatsResponse> params) {
+ StreamConfig::SetTransactionHeaderFor::GetSupportedFormatsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamConfig::Interface::WatchGainStateCompleterBase::Reply(::llcpp::fuchsia::hardware::audio::GainState gain_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchGainStateResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ WatchGainStateResponse _response = {};
+ StreamConfig::SetTransactionHeaderFor::WatchGainStateResponse(
+ ::fidl::DecodedMessage<WatchGainStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchGainStateResponse::PrimarySize,
+ WatchGainStateResponse::PrimarySize)));
+ _response.gain_state = std::move(gain_state);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamConfig::Interface::WatchGainStateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::GainState gain_state) {
+ if (_buffer.capacity() < WatchGainStateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WatchGainStateResponse _response = {};
+ StreamConfig::SetTransactionHeaderFor::WatchGainStateResponse(
+ ::fidl::DecodedMessage<WatchGainStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchGainStateResponse::PrimarySize,
+ WatchGainStateResponse::PrimarySize)));
+ _response.gain_state = std::move(gain_state);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamConfig::Interface::WatchGainStateCompleterBase::Reply(::fidl::DecodedMessage<WatchGainStateResponse> params) {
+ StreamConfig::SetTransactionHeaderFor::WatchGainStateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamConfig::Interface::WatchPlugStateCompleterBase::Reply(::llcpp::fuchsia::hardware::audio::PlugState plug_state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchPlugStateResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ WatchPlugStateResponse _response = {};
+ StreamConfig::SetTransactionHeaderFor::WatchPlugStateResponse(
+ ::fidl::DecodedMessage<WatchPlugStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchPlugStateResponse::PrimarySize,
+ WatchPlugStateResponse::PrimarySize)));
+ _response.plug_state = std::move(plug_state);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamConfig::Interface::WatchPlugStateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::PlugState plug_state) {
+ if (_buffer.capacity() < WatchPlugStateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WatchPlugStateResponse _response = {};
+ StreamConfig::SetTransactionHeaderFor::WatchPlugStateResponse(
+ ::fidl::DecodedMessage<WatchPlugStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchPlugStateResponse::PrimarySize,
+ WatchPlugStateResponse::PrimarySize)));
+ _response.plug_state = std::move(plug_state);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamConfig::Interface::WatchPlugStateCompleterBase::Reply(::fidl::DecodedMessage<WatchPlugStateResponse> params) {
+ StreamConfig::SetTransactionHeaderFor::WatchPlugStateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void StreamConfig::SetTransactionHeaderFor::GetPropertiesRequest(const ::fidl::DecodedMessage<StreamConfig::GetPropertiesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_GetProperties_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamConfig::SetTransactionHeaderFor::GetPropertiesResponse(const ::fidl::DecodedMessage<StreamConfig::GetPropertiesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_GetProperties_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamConfig::SetTransactionHeaderFor::GetSupportedFormatsRequest(const ::fidl::DecodedMessage<StreamConfig::GetSupportedFormatsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_GetSupportedFormats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamConfig::SetTransactionHeaderFor::GetSupportedFormatsResponse(const ::fidl::DecodedMessage<StreamConfig::GetSupportedFormatsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_GetSupportedFormats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamConfig::SetTransactionHeaderFor::CreateRingBufferRequest(const ::fidl::DecodedMessage<StreamConfig::CreateRingBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_CreateRingBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamConfig::SetTransactionHeaderFor::WatchGainStateRequest(const ::fidl::DecodedMessage<StreamConfig::WatchGainStateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_WatchGainState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamConfig::SetTransactionHeaderFor::WatchGainStateResponse(const ::fidl::DecodedMessage<StreamConfig::WatchGainStateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_WatchGainState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamConfig::SetTransactionHeaderFor::SetGainRequest(const ::fidl::DecodedMessage<StreamConfig::SetGainRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_SetGain_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamConfig::SetTransactionHeaderFor::WatchPlugStateRequest(const ::fidl::DecodedMessage<StreamConfig::WatchPlugStateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_WatchPlugState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamConfig::SetTransactionHeaderFor::WatchPlugStateResponse(const ::fidl::DecodedMessage<StreamConfig::WatchPlugStateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamConfig_WatchPlugState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace audio
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-audio/gen/llcpp/include/fuchsia/hardware/audio/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-audio/gen/llcpp/include/fuchsia/hardware/audio/llcpp/fidl.h
new file mode 100644
index 0000000..5c13e1e
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-audio/gen/llcpp/include/fuchsia/hardware/audio/llcpp/fidl.h
@@ -0,0 +1,2564 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace audio {
+
+struct RingBufferPositionInfo;
+struct PlugState;
+struct RingBufferProperties;
+class Device;
+enum class SampleFormat : uint8_t {
+ PCM_SIGNED = 1u,
+ PCM_UNSIGNED = 2u,
+ PCM_FLOAT = 3u,
+};
+
+
+struct PcmSupportedFormats;
+struct SupportedFormats;
+struct PcmFormat;
+struct Format;
+struct RingBuffer_GetVmo_Response;
+enum class PlugDetectCapabilities : uint32_t {
+ HARDWIRED = 0u,
+ CAN_ASYNC_NOTIFY = 1u,
+};
+
+
+struct StreamProperties;
+enum class GetVmoError : uint32_t {
+ INVALID_ARGS = 1u,
+ INTERNAL_ERROR = 2u,
+};
+
+
+struct RingBuffer_GetVmo_Result;
+class RingBuffer;
+struct GainState;
+class StreamConfig;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_PlugStateTable;
+
+// Plug state as returned by the driver.
+struct PlugState final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Stream is currently plugged in. Must be included.
+ const bool& plugged() const {
+ ZX_ASSERT(has_plugged());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool& plugged() {
+ ZX_ASSERT(has_plugged());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_plugged() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Timestamps the information provided in the rest of the fields of this struct.
+ // Must be included.
+ const int64_t& plug_state_time() const {
+ ZX_ASSERT(has_plug_state_time());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ int64_t& plug_state_time() {
+ ZX_ASSERT(has_plug_state_time());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_plug_state_time() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ PlugState() = default;
+ ~PlugState() = default;
+ PlugState(PlugState&& other) noexcept = default;
+ PlugState& operator=(PlugState&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_PlugStateTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 48;
+ static constexpr bool HasPointer = true;
+
+ private:
+ PlugState(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class PlugState::Builder {
+ public:
+ PlugState view() { return PlugState(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Stream is currently plugged in. Must be included.
+ Builder&& set_plugged(bool* elem);
+
+ // Timestamps the information provided in the rest of the fields of this struct.
+ // Must be included.
+ Builder&& set_plug_state_time(int64_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder PlugState::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 2> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferPropertiesTable;
+
+struct RingBufferProperties final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The driver's best estimate of the external delay (in nanoseconds) present in the
+ // presentation pipeline for the chosen format. When precisely synchronizing presentation
+ // across multiple entities (e.g. devices), the external delay should be taken into account.
+ const int64_t& external_delay() const {
+ ZX_ASSERT(has_external_delay());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ int64_t& external_delay() {
+ ZX_ASSERT(has_external_delay());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_external_delay() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Size (in bytes) representing a temporary buffer used by the driver in order to consume or
+ // generate the ring buffer contents. The ring buffer contents must be produced and consumed
+ // at the rate specified with the |CreateRingBuffer| command, however some amount of buffering
+ // is required when the data is written into and read from the ring buffer. For playback the
+ // data is consumed by the driver by reading ahead up to |fifo_depth| bytes. For capture the
+ // data is produced by the driver holding up to |fifo_depth| bytes at the time before
+ // committing it to main system memory. Hence |fifo_depth| must be taken into account by the
+ // client when determining either the minimum lead time requirement (for playback) or the
+ // maximum capture delay (for capture).
+ //
+ // To convert |fifo_depth| to the corresponding number of audio frames, use the frame size
+ // returned by |CreateRingBuffer| in the |StreamConfig| protocol, note that the |fifo_depth|
+ // is not necessarily a multiple size of an audio frame.
+ //
+ // The ring buffer data may be directly consumed/generated by hardware, in this case
+ // |fifo_depth| maps directly to the size of a hardware FIFO block, since the hardware FIFO
+ // block determines the amount of data read ahead or held back.
+ //
+ // The ring buffer data may instead be consumed/generated by audio driver software that is
+ // conceptually situated between the ring buffer and the audio hardware. In this case, for
+ // playback the |fifo_depth| read ahead amount is set large enough such that the driver
+ // guarantees no undetected underruns, this assuming the client is generating the data as
+ // determined by the |CreateRingBuffer| and |Start| commands. For capture, the
+ // |fifo_depth| held back amount is set large enough such that the driver guarantees no
+ // undetected underruns when generating the data as determined by the |CreateRingBuffer| and
+ // |Start| commands. The driver must set |fifo_depth| big enough such that the potential
+ // delays added by any software interfacing with the audio hardware do not occur under most
+ // scenarios, and must detect and report underruns. How an underrun is reported is not defined
+ // in this API.
+ const uint32_t& fifo_depth() const {
+ ZX_ASSERT(has_fifo_depth());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ uint32_t& fifo_depth() {
+ ZX_ASSERT(has_fifo_depth());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_fifo_depth() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // An identifier for the clock domain in which this hardware operates. If the hardware is
+ // operating in CLOCK_DOMAIN_MONOTONIC, its nominal rate is locked to that of the
+ // ZX_CLOCK_MONOTONIC time reference. Given the start time, and a nominal rate, the position
+ // of the playback/capture pointer may always be calculated using a clock monotonic timestamp
+ // as the pointer's movement is locked to that of ZX_CLOCK_MONOTONIC.
+ //
+ // Other values indicate that playback/capture is not locked to ZX_CLOCK_MONOTONIC, and moves
+ // at its own rate depending on a number of factors. Client will need to make use of the
+ // timing information present in the position notification updates in order to recover the
+ // clock of the audio stream. The clock_domain comes from an system wide entity (or instance a
+ // platform bus or clock tree/global driver). Audio drivers retrieve clock_domain from such
+ // system wide entity.
+ const uint32_t& clock_domain() const {
+ ZX_ASSERT(has_clock_domain());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ uint32_t& clock_domain() {
+ ZX_ASSERT(has_clock_domain());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_clock_domain() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // When set to true, indicates that clients need to make sure that their data has been flushed
+ // all the way to physical memory (in the case of playback) or that their view of the ring
+ // buffer will need to be invalidated before read (in the case of capture).
+ const bool& needs_cache_flush_or_invalidate() const {
+ ZX_ASSERT(has_needs_cache_flush_or_invalidate());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool& needs_cache_flush_or_invalidate() {
+ ZX_ASSERT(has_needs_cache_flush_or_invalidate());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_needs_cache_flush_or_invalidate() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ RingBufferProperties() = default;
+ ~RingBufferProperties() = default;
+ RingBufferProperties(RingBufferProperties&& other) noexcept = default;
+ RingBufferProperties& operator=(RingBufferProperties&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBufferPropertiesTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 96;
+ static constexpr bool HasPointer = true;
+
+ private:
+ RingBufferProperties(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class RingBufferProperties::Builder {
+ public:
+ RingBufferProperties view() { return RingBufferProperties(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The driver's best estimate of the external delay (in nanoseconds) present in the
+ // presentation pipeline for the chosen format. When precisely synchronizing presentation
+ // across multiple entities (e.g. devices), the external delay should be taken into account.
+ Builder&& set_external_delay(int64_t* elem);
+
+ // Size (in bytes) representing a temporary buffer used by the driver in order to consume or
+ // generate the ring buffer contents. The ring buffer contents must be produced and consumed
+ // at the rate specified with the |CreateRingBuffer| command, however some amount of buffering
+ // is required when the data is written into and read from the ring buffer. For playback the
+ // data is consumed by the driver by reading ahead up to |fifo_depth| bytes. For capture the
+ // data is produced by the driver holding up to |fifo_depth| bytes at the time before
+ // committing it to main system memory. Hence |fifo_depth| must be taken into account by the
+ // client when determining either the minimum lead time requirement (for playback) or the
+ // maximum capture delay (for capture).
+ //
+ // To convert |fifo_depth| to the corresponding number of audio frames, use the frame size
+ // returned by |CreateRingBuffer| in the |StreamConfig| protocol, note that the |fifo_depth|
+ // is not necessarily a multiple size of an audio frame.
+ //
+ // The ring buffer data may be directly consumed/generated by hardware, in this case
+ // |fifo_depth| maps directly to the size of a hardware FIFO block, since the hardware FIFO
+ // block determines the amount of data read ahead or held back.
+ //
+ // The ring buffer data may instead be consumed/generated by audio driver software that is
+ // conceptually situated between the ring buffer and the audio hardware. In this case, for
+ // playback the |fifo_depth| read ahead amount is set large enough such that the driver
+ // guarantees no undetected underruns, this assuming the client is generating the data as
+ // determined by the |CreateRingBuffer| and |Start| commands. For capture, the
+ // |fifo_depth| held back amount is set large enough such that the driver guarantees no
+ // undetected underruns when generating the data as determined by the |CreateRingBuffer| and
+ // |Start| commands. The driver must set |fifo_depth| big enough such that the potential
+ // delays added by any software interfacing with the audio hardware do not occur under most
+ // scenarios, and must detect and report underruns. How an underrun is reported is not defined
+ // in this API.
+ Builder&& set_fifo_depth(uint32_t* elem);
+
+ // An identifier for the clock domain in which this hardware operates. If the hardware is
+ // operating in CLOCK_DOMAIN_MONOTONIC, its nominal rate is locked to that of the
+ // ZX_CLOCK_MONOTONIC time reference. Given the start time, and a nominal rate, the position
+ // of the playback/capture pointer may always be calculated using a clock monotonic timestamp
+ // as the pointer's movement is locked to that of ZX_CLOCK_MONOTONIC.
+ //
+ // Other values indicate that playback/capture is not locked to ZX_CLOCK_MONOTONIC, and moves
+ // at its own rate depending on a number of factors. Client will need to make use of the
+ // timing information present in the position notification updates in order to recover the
+ // clock of the audio stream. The clock_domain comes from an system wide entity (or instance a
+ // platform bus or clock tree/global driver). Audio drivers retrieve clock_domain from such
+ // system wide entity.
+ Builder&& set_clock_domain(uint32_t* elem);
+
+ // When set to true, indicates that clients need to make sure that their data has been flushed
+ // all the way to physical memory (in the case of playback) or that their view of the ring
+ // buffer will need to be invalidated before read (in the case of capture).
+ Builder&& set_needs_cache_flush_or_invalidate(bool* elem);
+
+ private:
+ Builder() = default;
+ friend Builder RingBufferProperties::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 4> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_SupportedFormatsTable;
+
+struct SupportedFormats final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Supported formats for non-compressed PCM samples.
+ const ::llcpp::fuchsia::hardware::audio::PcmSupportedFormats& pcm_supported_formats() const {
+ ZX_ASSERT(has_pcm_supported_formats());
+ return *reinterpret_cast<const ::llcpp::fuchsia::hardware::audio::PcmSupportedFormats*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::hardware::audio::PcmSupportedFormats& pcm_supported_formats() {
+ ZX_ASSERT(has_pcm_supported_formats());
+ return *reinterpret_cast<::llcpp::fuchsia::hardware::audio::PcmSupportedFormats*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_pcm_supported_formats() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ SupportedFormats() = default;
+ ~SupportedFormats() = default;
+ SupportedFormats(SupportedFormats&& other) noexcept = default;
+ SupportedFormats& operator=(SupportedFormats&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_SupportedFormatsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 440;
+ static constexpr bool HasPointer = true;
+
+ private:
+ SupportedFormats(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class SupportedFormats::Builder {
+ public:
+ SupportedFormats view() { return SupportedFormats(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Supported formats for non-compressed PCM samples.
+ Builder&& set_pcm_supported_formats(::llcpp::fuchsia::hardware::audio::PcmSupportedFormats* elem);
+
+ private:
+ Builder() = default;
+ friend Builder SupportedFormats::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_FormatTable;
+
+struct Format final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Format supporting non-compressed PCM samples.
+ const ::llcpp::fuchsia::hardware::audio::PcmFormat& pcm_format() const {
+ ZX_ASSERT(has_pcm_format());
+ return *reinterpret_cast<const ::llcpp::fuchsia::hardware::audio::PcmFormat*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::hardware::audio::PcmFormat& pcm_format() {
+ ZX_ASSERT(has_pcm_format());
+ return *reinterpret_cast<::llcpp::fuchsia::hardware::audio::PcmFormat*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_pcm_format() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ Format() = default;
+ ~Format() = default;
+ Format(Format&& other) noexcept = default;
+ Format& operator=(Format&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_FormatTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 40;
+ static constexpr bool HasPointer = true;
+
+ private:
+ Format(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class Format::Builder {
+ public:
+ Format view() { return Format(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Format supporting non-compressed PCM samples.
+ Builder&& set_pcm_format(::llcpp::fuchsia::hardware::audio::PcmFormat* elem);
+
+ private:
+ Builder() = default;
+ friend Builder Format::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamPropertiesTable;
+
+struct StreamProperties final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // A unique identifier. If not included, there is no unique id for the StreamConfig.
+ const ::fidl::Array<uint8_t, 16>& unique_id() const {
+ ZX_ASSERT(has_unique_id());
+ return *reinterpret_cast<const ::fidl::Array<uint8_t, 16>*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::fidl::Array<uint8_t, 16>& unique_id() {
+ ZX_ASSERT(has_unique_id());
+ return *reinterpret_cast<::fidl::Array<uint8_t, 16>*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_unique_id() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Stream type is input or output. Must be included.
+ const bool& is_input() const {
+ ZX_ASSERT(has_is_input());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool& is_input() {
+ ZX_ASSERT(has_is_input());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_is_input() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // Gain mute capability. If not included, the StreamConfig can't mute.
+ const bool& can_mute() const {
+ ZX_ASSERT(has_can_mute());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool& can_mute() {
+ ZX_ASSERT(has_can_mute());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_can_mute() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // Automatic Gain Control (AGC) capability. If not included, the StreamConfig can't AGC.
+ const bool& can_agc() const {
+ ZX_ASSERT(has_can_agc());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool& can_agc() {
+ ZX_ASSERT(has_can_agc());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_can_agc() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ // Minimum gain in decibels. Must be included.
+ const float& min_gain_db() const {
+ ZX_ASSERT(has_min_gain_db());
+ return *reinterpret_cast<const float*>(EnvelopesView::at(5 - 1).data);
+ }
+ float& min_gain_db() {
+ ZX_ASSERT(has_min_gain_db());
+ return *reinterpret_cast<float*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_min_gain_db() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ // Maximum gain in decibels. Must be included.
+ const float& max_gain_db() const {
+ ZX_ASSERT(has_max_gain_db());
+ return *reinterpret_cast<const float*>(EnvelopesView::at(6 - 1).data);
+ }
+ float& max_gain_db() {
+ ZX_ASSERT(has_max_gain_db());
+ return *reinterpret_cast<float*>(EnvelopesView::at(6 - 1).data);
+ }
+ bool has_max_gain_db() const {
+ return EnvelopesView::count() >= 6 && EnvelopesView::at(6 - 1).data != nullptr;
+ }
+
+ // Gain step in decibels, this value must not be negative, but may be zero to convey an
+ // effectively continuous range of values. Must be included.
+ const float& gain_step_db() const {
+ ZX_ASSERT(has_gain_step_db());
+ return *reinterpret_cast<const float*>(EnvelopesView::at(7 - 1).data);
+ }
+ float& gain_step_db() {
+ ZX_ASSERT(has_gain_step_db());
+ return *reinterpret_cast<float*>(EnvelopesView::at(7 - 1).data);
+ }
+ bool has_gain_step_db() const {
+ return EnvelopesView::count() >= 7 && EnvelopesView::at(7 - 1).data != nullptr;
+ }
+
+ // Plug Detect Capabilities. Must be included.
+ const ::llcpp::fuchsia::hardware::audio::PlugDetectCapabilities& plug_detect_capabilities() const {
+ ZX_ASSERT(has_plug_detect_capabilities());
+ return *reinterpret_cast<const ::llcpp::fuchsia::hardware::audio::PlugDetectCapabilities*>(EnvelopesView::at(8 - 1).data);
+ }
+ ::llcpp::fuchsia::hardware::audio::PlugDetectCapabilities& plug_detect_capabilities() {
+ ZX_ASSERT(has_plug_detect_capabilities());
+ return *reinterpret_cast<::llcpp::fuchsia::hardware::audio::PlugDetectCapabilities*>(EnvelopesView::at(8 - 1).data);
+ }
+ bool has_plug_detect_capabilities() const {
+ return EnvelopesView::count() >= 8 && EnvelopesView::at(8 - 1).data != nullptr;
+ }
+
+ // UI string for the manufacturer name. If not included, the manufacturer is unspecified.
+ const ::fidl::StringView& manufacturer() const {
+ ZX_ASSERT(has_manufacturer());
+ return *reinterpret_cast<const ::fidl::StringView*>(EnvelopesView::at(9 - 1).data);
+ }
+ ::fidl::StringView& manufacturer() {
+ ZX_ASSERT(has_manufacturer());
+ return *reinterpret_cast<::fidl::StringView*>(EnvelopesView::at(9 - 1).data);
+ }
+ bool has_manufacturer() const {
+ return EnvelopesView::count() >= 9 && EnvelopesView::at(9 - 1).data != nullptr;
+ }
+
+ // UI string for the product name. If not included, the product name is unspecified.
+ const ::fidl::StringView& product() const {
+ ZX_ASSERT(has_product());
+ return *reinterpret_cast<const ::fidl::StringView*>(EnvelopesView::at(10 - 1).data);
+ }
+ ::fidl::StringView& product() {
+ ZX_ASSERT(has_product());
+ return *reinterpret_cast<::fidl::StringView*>(EnvelopesView::at(10 - 1).data);
+ }
+ bool has_product() const {
+ return EnvelopesView::count() >= 10 && EnvelopesView::at(10 - 1).data != nullptr;
+ }
+
+ StreamProperties() = default;
+ ~StreamProperties() = default;
+ StreamProperties(StreamProperties&& other) noexcept = default;
+ StreamProperties& operator=(StreamProperties&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_StreamPropertiesTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 776;
+ static constexpr bool HasPointer = true;
+
+ private:
+ StreamProperties(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class StreamProperties::Builder {
+ public:
+ StreamProperties view() { return StreamProperties(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // A unique identifier. If not included, there is no unique id for the StreamConfig.
+ Builder&& set_unique_id(::fidl::Array<uint8_t, 16>* elem);
+
+ // Stream type is input or output. Must be included.
+ Builder&& set_is_input(bool* elem);
+
+ // Gain mute capability. If not included, the StreamConfig can't mute.
+ Builder&& set_can_mute(bool* elem);
+
+ // Automatic Gain Control (AGC) capability. If not included, the StreamConfig can't AGC.
+ Builder&& set_can_agc(bool* elem);
+
+ // Minimum gain in decibels. Must be included.
+ Builder&& set_min_gain_db(float* elem);
+
+ // Maximum gain in decibels. Must be included.
+ Builder&& set_max_gain_db(float* elem);
+
+ // Gain step in decibels, this value must not be negative, but may be zero to convey an
+ // effectively continuous range of values. Must be included.
+ Builder&& set_gain_step_db(float* elem);
+
+ // Plug Detect Capabilities. Must be included.
+ Builder&& set_plug_detect_capabilities(::llcpp::fuchsia::hardware::audio::PlugDetectCapabilities* elem);
+
+ // UI string for the manufacturer name. If not included, the manufacturer is unspecified.
+ Builder&& set_manufacturer(::fidl::StringView* elem);
+
+ // UI string for the product name. If not included, the product name is unspecified.
+ Builder&& set_product(::fidl::StringView* elem);
+
+ private:
+ Builder() = default;
+ friend Builder StreamProperties::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 10> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBuffer_GetVmo_ResultTable;
+
+struct RingBuffer_GetVmo_Result {
+ RingBuffer_GetVmo_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static RingBuffer_GetVmo_Result WithResponse(::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response* val) {
+ RingBuffer_GetVmo_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static RingBuffer_GetVmo_Result WithErr(::llcpp::fuchsia::hardware::audio::GetVmoError* val) {
+ RingBuffer_GetVmo_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(::llcpp::fuchsia::hardware::audio::GetVmoError* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::audio::GetVmoError& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<::llcpp::fuchsia::hardware::audio::GetVmoError*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::audio::GetVmoError& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<::llcpp::fuchsia::hardware::audio::GetVmoError*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBuffer_GetVmo_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_GainStateTable;
+
+// Gain state requested by the client or returned a current by the driver.
+struct GainState final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Current mute state. If not included, the state is unmuted.
+ const bool& muted() const {
+ ZX_ASSERT(has_muted());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool& muted() {
+ ZX_ASSERT(has_muted());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_muted() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Current Automatic Gain Control (AGC) state. If not included, AGC is disabled.
+ const bool& agc_enabled() const {
+ ZX_ASSERT(has_agc_enabled());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool& agc_enabled() {
+ ZX_ASSERT(has_agc_enabled());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_agc_enabled() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // Current gain in decibels. Must be included.
+ const float& gain_db() const {
+ ZX_ASSERT(has_gain_db());
+ return *reinterpret_cast<const float*>(EnvelopesView::at(3 - 1).data);
+ }
+ float& gain_db() {
+ ZX_ASSERT(has_gain_db());
+ return *reinterpret_cast<float*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_gain_db() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ GainState() = default;
+ ~GainState() = default;
+ GainState(GainState&& other) noexcept = default;
+ GainState& operator=(GainState&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_GainStateTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr bool HasPointer = true;
+
+ private:
+ GainState(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class GainState::Builder {
+ public:
+ GainState view() { return GainState(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Current mute state. If not included, the state is unmuted.
+ Builder&& set_muted(bool* elem);
+
+ // Current Automatic Gain Control (AGC) state. If not included, AGC is disabled.
+ Builder&& set_agc_enabled(bool* elem);
+
+ // Current gain in decibels. Must be included.
+ Builder&& set_gain_db(float* elem);
+
+ private:
+ Builder() = default;
+ friend Builder GainState::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 3> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferPositionInfoTable;
+
+struct RingBufferPositionInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBufferPositionInfoTable;
+ 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;
+
+ // The driver's best estimate of the time at which the playback/capture pointer reached the
+ // position indicated by |position|.
+ int64_t timestamp = {};
+
+ // The playback/capture pointer position (in bytes) in the ring buffer at time
+ // |timestamp| as estimated by the driver.
+ uint32_t position = {};
+};
+
+constexpr uint32_t CLOCK_DOMAIN_MONOTONIC = 0u;
+
+constexpr uint32_t CLOCK_DOMAIN_EXTERNAL = 4294967295u;
+
+constexpr uint32_t UNIQUE_ID_SIZE = 16u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_DeviceGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_DeviceGetChannelResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetChannelResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel channel;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_DeviceGetChannelResponseTable;
+ 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 GetChannelRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetChannel_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_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 GetChannel = GetChannel_Impl<GetChannelResponse>;
+ };
+
+ // 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 GetChannel_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_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 GetChannel = GetChannel_Impl<GetChannelResponse>;
+ };
+
+ 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_; }
+
+ // This method obtains a channel in order to serve FIDL over it outside the devhost's control.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetChannel GetChannel();
+
+ // This method obtains a channel in order to serve FIDL over it outside the devhost's control.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetChannel GetChannel(::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:
+
+ // This method obtains a channel in order to serve FIDL over it outside the devhost's control.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetChannel GetChannel(::zx::unowned_channel _client_end);
+
+ // This method obtains a channel in order to serve FIDL over it outside the devhost's control.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetChannel GetChannel(::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:
+
+ // This method obtains a channel in order to serve FIDL over it outside the devhost's control.
+ static ::fidl::DecodeResult<GetChannelResponse> GetChannel(::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 = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetChannelCompleterBase : public _Base {
+ public:
+ void Reply(::zx::channel channel);
+ void Reply(::fidl::BytePart _buffer, ::zx::channel channel);
+ void Reply(::fidl::DecodedMessage<GetChannelResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetChannelCompleter = ::fidl::Completer<GetChannelCompleterBase>;
+
+ virtual void GetChannel(GetChannelCompleter::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 GetChannelRequest(const ::fidl::DecodedMessage<Device::GetChannelRequest>& _msg);
+ static void GetChannelResponse(const ::fidl::DecodedMessage<Device::GetChannelResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_PcmSupportedFormatsTable;
+
+// Format supporting non-compressed PCM audio. Frames are made up of |number_of_channels| samples
+// which have |valid_bits_per_sample| bits of left-justified data within |bytes_per_sample|
+// bytes. All values listed in each vector are supported. When not all combinations supported by
+// the driver can be described with one |SupportedFormats| (and hence one |PcmSupportedFormats|),
+// |GetSupportedFormats| returns more than one |SupportedFormats| in the returned vector.
+// For more detailed information see //zircon/driver_interfaces/audio_streaming.md.
+struct PcmSupportedFormats {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_PcmSupportedFormatsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 344;
+ static constexpr bool HasPointer = true;
+
+ // Vector of possible number of channels supported in ascending order.
+ ::fidl::VectorView<uint8_t> number_of_channels = {};
+
+ // Vector of possible |SampleFormat|s supported.
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::audio::SampleFormat> sample_formats = {};
+
+ // Vector of possible number of bits allocated to hold a sample,
+ // equal or bigger than the actual sample size in |valid_bits_per_sample| in ascending order.
+ ::fidl::VectorView<uint8_t> bytes_per_sample = {};
+
+ // Vector of possible number of bits in a sample in ascending order, must be equal or smaller
+ // than |bytes_per_channel| for samples to fit. If smaller, bits are left justified, and any
+ // additional bits will be ignored.
+ ::fidl::VectorView<uint8_t> valid_bits_per_sample = {};
+
+ // Vector of possible frame rates supported in ascending order.
+ ::fidl::VectorView<uint32_t> frame_rates = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_PcmFormatTable;
+
+// Format supporting non-compressed PCM audio. Frames are made up of |number_of_channels| samples
+// which have |valid_bits_per_sample| bits of left-justified data within |bytes_per_channel|.
+// bytes. For more detailed information see //zircon/driver_interfaces/audio_streaming.md.
+struct PcmFormat {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_PcmFormatTable;
+ 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;
+
+ // Number of channels.
+ uint8_t number_of_channels = {};
+
+ // Which channels to use as a bitmask. Channels not set in the bitmask are ignored.
+ // The least significant bit corresponds to index 0.
+ uint64_t channels_to_use_bitmask = {};
+
+ // The format of all samples.
+ ::llcpp::fuchsia::hardware::audio::SampleFormat sample_format = {};
+
+ // Bytes allocated to hold a sample, equal or bigger than the valid sample size in
+ // |valid_bits_per_sample|.
+ uint8_t bytes_per_sample = {};
+
+ // Number of valid bits in a sample, must be equal or smaller than bits in |bytes_per_sample|.
+ // If smaller, bits are left justified, and any additional bits must be ignored by the
+ // receiver.
+ uint8_t valid_bits_per_sample = {};
+
+ // The frame rate for all samples.
+ uint32_t frame_rate = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBuffer_GetVmo_ResponseTable;
+
+struct RingBuffer_GetVmo_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBuffer_GetVmo_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t num_frames = {};
+
+ ::zx::vmo ring_buffer = {};
+};
+
+constexpr uint32_t MAX_UI_STRING_SIZE = 256u;
+
+constexpr uint32_t MAX_COUNT_SUPPORTED_VALID_BITS_PER_SAMPLE = 8u;
+
+constexpr uint32_t MAX_COUNT_SUPPORTED_SAMPLE_FORMATS = 3u;
+
+constexpr uint32_t MAX_COUNT_SUPPORTED_RATES = 64u;
+
+constexpr uint32_t MAX_COUNT_SUPPORTED_NUMBER_OF_CHANNELS = 64u;
+
+constexpr uint32_t MAX_COUNT_SUPPORTED_BYTES_PER_SAMPLE = 8u;
+
+constexpr uint32_t MAX_COUNT_FORMATS = 64u;
+
+constexpr uint32_t MAX_COUNT_CHANNELS_TO_USE = 64u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferGetPropertiesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferGetPropertiesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferWatchClockRecoveryPositionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferWatchClockRecoveryPositionInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferGetVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferGetVmoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferStartResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_RingBufferStopResponseTable;
+
+class RingBuffer final {
+ RingBuffer() = delete;
+ public:
+
+ struct GetPropertiesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::audio::RingBufferProperties properties;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBufferGetPropertiesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 96;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetPropertiesRequest = ::fidl::AnyZeroArgMessage;
+
+ struct WatchClockRecoveryPositionInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo position_info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBufferWatchClockRecoveryPositionInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 WatchClockRecoveryPositionInfoRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetVmoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBufferGetVmoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetVmoRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t min_frames;
+ uint32_t clock_recovery_notifications_per_ring;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBufferGetVmoRequestTable;
+ 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 = GetVmoResponse;
+ };
+
+ struct StartResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int64_t start_time;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_RingBufferStartResponseTable;
+ 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 StartRequest = ::fidl::AnyZeroArgMessage;
+
+ using StopResponse = ::fidl::AnyZeroArgMessage;
+ using StopRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetProperties_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetProperties_Impl(::zx::unowned_channel _client_end);
+ ~GetProperties_Impl() = default;
+ GetProperties_Impl(GetProperties_Impl&& other) = default;
+ GetProperties_Impl& operator=(GetProperties_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 WatchClockRecoveryPositionInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WatchClockRecoveryPositionInfo_Impl(::zx::unowned_channel _client_end);
+ ~WatchClockRecoveryPositionInfo_Impl() = default;
+ WatchClockRecoveryPositionInfo_Impl(WatchClockRecoveryPositionInfo_Impl&& other) = default;
+ WatchClockRecoveryPositionInfo_Impl& operator=(WatchClockRecoveryPositionInfo_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 GetVmo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetVmo_Impl(::zx::unowned_channel _client_end, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring);
+ ~GetVmo_Impl() = default;
+ GetVmo_Impl(GetVmo_Impl&& other) = default;
+ GetVmo_Impl& operator=(GetVmo_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 Start_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Start_Impl(::zx::unowned_channel _client_end);
+ ~Start_Impl() = default;
+ Start_Impl(Start_Impl&& other) = default;
+ Start_Impl& operator=(Start_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 Stop_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Stop_Impl(::zx::unowned_channel _client_end);
+ ~Stop_Impl() = default;
+ Stop_Impl(Stop_Impl&& other) = default;
+ Stop_Impl& operator=(Stop_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 GetProperties = GetProperties_Impl<GetPropertiesResponse>;
+ using WatchClockRecoveryPositionInfo = WatchClockRecoveryPositionInfo_Impl<WatchClockRecoveryPositionInfoResponse>;
+ using GetVmo = GetVmo_Impl<GetVmoResponse>;
+ using Start = Start_Impl<StartResponse>;
+ using Stop = Stop_Impl<StopResponse>;
+ };
+
+ // 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 GetProperties_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetProperties_Impl() = default;
+ GetProperties_Impl(GetProperties_Impl&& other) = default;
+ GetProperties_Impl& operator=(GetProperties_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 WatchClockRecoveryPositionInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WatchClockRecoveryPositionInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WatchClockRecoveryPositionInfo_Impl() = default;
+ WatchClockRecoveryPositionInfo_Impl(WatchClockRecoveryPositionInfo_Impl&& other) = default;
+ WatchClockRecoveryPositionInfo_Impl& operator=(WatchClockRecoveryPositionInfo_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 GetVmo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring, ::fidl::BytePart _response_buffer);
+ ~GetVmo_Impl() = default;
+ GetVmo_Impl(GetVmo_Impl&& other) = default;
+ GetVmo_Impl& operator=(GetVmo_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 Start_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Start_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Start_Impl() = default;
+ Start_Impl(Start_Impl&& other) = default;
+ Start_Impl& operator=(Start_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 Stop_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Stop_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Stop_Impl() = default;
+ Stop_Impl(Stop_Impl&& other) = default;
+ Stop_Impl& operator=(Stop_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 GetProperties = GetProperties_Impl<GetPropertiesResponse>;
+ using WatchClockRecoveryPositionInfo = WatchClockRecoveryPositionInfo_Impl<WatchClockRecoveryPositionInfoResponse>;
+ using GetVmo = GetVmo_Impl<GetVmoResponse>;
+ using Start = Start_Impl<StartResponse>;
+ using Stop = Stop_Impl<StopResponse>;
+ };
+
+ 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_; }
+
+ // Accessor for top level static properties.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetProperties GetProperties();
+
+ // Accessor for top level static properties.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetProperties GetProperties(::fidl::BytePart _response_buffer);
+
+ // Gets the ring buffer current position via a hanging get. The driver must immediately
+ // respond to a client's first |WatchClockRecoveryPositionInfo| call, but will not respond to
+ // subsequent client calls until the position information has changed from what was most
+ // recently provided to that client. If |clock_recovery_notifications_per_ring| is not zero,
+ // the driver will reply with its estimated position to be used for clock recovery at most at
+ // |clock_recovery_notifications_per_ring| frequency.
+ // Must be delivered with timestamps that are monotonically increasing.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WatchClockRecoveryPositionInfo WatchClockRecoveryPositionInfo();
+
+ // Gets the ring buffer current position via a hanging get. The driver must immediately
+ // respond to a client's first |WatchClockRecoveryPositionInfo| call, but will not respond to
+ // subsequent client calls until the position information has changed from what was most
+ // recently provided to that client. If |clock_recovery_notifications_per_ring| is not zero,
+ // the driver will reply with its estimated position to be used for clock recovery at most at
+ // |clock_recovery_notifications_per_ring| frequency.
+ // Must be delivered with timestamps that are monotonically increasing.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WatchClockRecoveryPositionInfo WatchClockRecoveryPositionInfo(::fidl::BytePart _response_buffer);
+
+ // Requests a shared buffer to be used for moving bulk audio data. Requests the buffer size to
+ // fit at least |min_frames|, and returns the actual |num_frames| allocated in
+ // |ring_buffer|.
+ //
+ // If |clock_recovery_notifications_per_ring| is non-zero, the driver will send replies to
+ // |WatchClockRecoveryPositionInfo| client requests at most at
+ // |clock_recovery_notifications_per_ring| frequency. These notifications are meant to be used
+ // for clock recovery.
+ //
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetVmo GetVmo(uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring);
+
+ // Requests a shared buffer to be used for moving bulk audio data. Requests the buffer size to
+ // fit at least |min_frames|, and returns the actual |num_frames| allocated in
+ // |ring_buffer|.
+ //
+ // If |clock_recovery_notifications_per_ring| is non-zero, the driver will send replies to
+ // |WatchClockRecoveryPositionInfo| client requests at most at
+ // |clock_recovery_notifications_per_ring| frequency. These notifications are meant to be used
+ // for clock recovery.
+ //
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetVmo GetVmo(::fidl::BytePart _request_buffer, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring, ::fidl::BytePart _response_buffer);
+
+ // Start the ring buffer.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Start Start();
+
+ // Start the ring buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Start Start(::fidl::BytePart _response_buffer);
+
+ // Stop the ring buffer. Once this call's response is received, no further position
+ // notifications will be sent until Start() is called again. TODO(39494): Add timestamp
+ // parameter.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Stop Stop();
+
+
+ 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:
+
+ // Accessor for top level static properties.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetProperties GetProperties(::zx::unowned_channel _client_end);
+
+ // Accessor for top level static properties.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetProperties GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Gets the ring buffer current position via a hanging get. The driver must immediately
+ // respond to a client's first |WatchClockRecoveryPositionInfo| call, but will not respond to
+ // subsequent client calls until the position information has changed from what was most
+ // recently provided to that client. If |clock_recovery_notifications_per_ring| is not zero,
+ // the driver will reply with its estimated position to be used for clock recovery at most at
+ // |clock_recovery_notifications_per_ring| frequency.
+ // Must be delivered with timestamps that are monotonically increasing.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WatchClockRecoveryPositionInfo WatchClockRecoveryPositionInfo(::zx::unowned_channel _client_end);
+
+ // Gets the ring buffer current position via a hanging get. The driver must immediately
+ // respond to a client's first |WatchClockRecoveryPositionInfo| call, but will not respond to
+ // subsequent client calls until the position information has changed from what was most
+ // recently provided to that client. If |clock_recovery_notifications_per_ring| is not zero,
+ // the driver will reply with its estimated position to be used for clock recovery at most at
+ // |clock_recovery_notifications_per_ring| frequency.
+ // Must be delivered with timestamps that are monotonically increasing.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WatchClockRecoveryPositionInfo WatchClockRecoveryPositionInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Requests a shared buffer to be used for moving bulk audio data. Requests the buffer size to
+ // fit at least |min_frames|, and returns the actual |num_frames| allocated in
+ // |ring_buffer|.
+ //
+ // If |clock_recovery_notifications_per_ring| is non-zero, the driver will send replies to
+ // |WatchClockRecoveryPositionInfo| client requests at most at
+ // |clock_recovery_notifications_per_ring| frequency. These notifications are meant to be used
+ // for clock recovery.
+ //
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetVmo GetVmo(::zx::unowned_channel _client_end, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring);
+
+ // Requests a shared buffer to be used for moving bulk audio data. Requests the buffer size to
+ // fit at least |min_frames|, and returns the actual |num_frames| allocated in
+ // |ring_buffer|.
+ //
+ // If |clock_recovery_notifications_per_ring| is non-zero, the driver will send replies to
+ // |WatchClockRecoveryPositionInfo| client requests at most at
+ // |clock_recovery_notifications_per_ring| frequency. These notifications are meant to be used
+ // for clock recovery.
+ //
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetVmo GetVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring, ::fidl::BytePart _response_buffer);
+
+ // Start the ring buffer.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Start Start(::zx::unowned_channel _client_end);
+
+ // Start the ring buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Start Start(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Stop the ring buffer. Once this call's response is received, no further position
+ // notifications will be sent until Start() is called again. TODO(39494): Add timestamp
+ // parameter.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Stop Stop(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // Accessor for top level static properties.
+ static ::fidl::DecodeResult<GetPropertiesResponse> GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Gets the ring buffer current position via a hanging get. The driver must immediately
+ // respond to a client's first |WatchClockRecoveryPositionInfo| call, but will not respond to
+ // subsequent client calls until the position information has changed from what was most
+ // recently provided to that client. If |clock_recovery_notifications_per_ring| is not zero,
+ // the driver will reply with its estimated position to be used for clock recovery at most at
+ // |clock_recovery_notifications_per_ring| frequency.
+ // Must be delivered with timestamps that are monotonically increasing.
+ static ::fidl::DecodeResult<WatchClockRecoveryPositionInfoResponse> WatchClockRecoveryPositionInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Requests a shared buffer to be used for moving bulk audio data. Requests the buffer size to
+ // fit at least |min_frames|, and returns the actual |num_frames| allocated in
+ // |ring_buffer|.
+ //
+ // If |clock_recovery_notifications_per_ring| is non-zero, the driver will send replies to
+ // |WatchClockRecoveryPositionInfo| client requests at most at
+ // |clock_recovery_notifications_per_ring| frequency. These notifications are meant to be used
+ // for clock recovery.
+ //
+ static ::fidl::DecodeResult<GetVmoResponse> GetVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetVmoRequest> params, ::fidl::BytePart response_buffer);
+
+ // Start the ring buffer.
+ static ::fidl::DecodeResult<StartResponse> Start(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Stop the ring buffer. Once this call's response is received, no further position
+ // notifications will be sent until Start() is called again. TODO(39494): Add timestamp
+ // parameter.
+ static ::fidl::DecodeResult<StopResponse> Stop(::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 = RingBuffer;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetPropertiesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::audio::RingBufferProperties properties);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::RingBufferProperties properties);
+ void Reply(::fidl::DecodedMessage<GetPropertiesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPropertiesCompleter = ::fidl::Completer<GetPropertiesCompleterBase>;
+
+ virtual void GetProperties(GetPropertiesCompleter::Sync _completer) = 0;
+
+ class WatchClockRecoveryPositionInfoCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo position_info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo position_info);
+ void Reply(::fidl::DecodedMessage<WatchClockRecoveryPositionInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchClockRecoveryPositionInfoCompleter = ::fidl::Completer<WatchClockRecoveryPositionInfoCompleterBase>;
+
+ virtual void WatchClockRecoveryPositionInfo(WatchClockRecoveryPositionInfoCompleter::Sync _completer) = 0;
+
+ class GetVmoCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Result result);
+ void ReplySuccess(uint32_t num_frames, ::zx::vmo ring_buffer);
+ void ReplyError(GetVmoError error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint32_t num_frames, ::zx::vmo ring_buffer);
+ void Reply(::fidl::DecodedMessage<GetVmoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetVmoCompleter = ::fidl::Completer<GetVmoCompleterBase>;
+
+ virtual void GetVmo(uint32_t min_frames, uint32_t clock_recovery_notifications_per_ring, GetVmoCompleter::Sync _completer) = 0;
+
+ class StartCompleterBase : public _Base {
+ public:
+ void Reply(int64_t start_time);
+ void Reply(::fidl::BytePart _buffer, int64_t start_time);
+ void Reply(::fidl::DecodedMessage<StartResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StartCompleter = ::fidl::Completer<StartCompleterBase>;
+
+ virtual void Start(StartCompleter::Sync _completer) = 0;
+
+ class StopCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StopCompleter = ::fidl::Completer<StopCompleterBase>;
+
+ virtual void Stop(StopCompleter::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 GetPropertiesRequest(const ::fidl::DecodedMessage<RingBuffer::GetPropertiesRequest>& _msg);
+ static void GetPropertiesResponse(const ::fidl::DecodedMessage<RingBuffer::GetPropertiesResponse>& _msg);
+ static void WatchClockRecoveryPositionInfoRequest(const ::fidl::DecodedMessage<RingBuffer::WatchClockRecoveryPositionInfoRequest>& _msg);
+ static void WatchClockRecoveryPositionInfoResponse(const ::fidl::DecodedMessage<RingBuffer::WatchClockRecoveryPositionInfoResponse>& _msg);
+ static void GetVmoRequest(const ::fidl::DecodedMessage<RingBuffer::GetVmoRequest>& _msg);
+ static void GetVmoResponse(const ::fidl::DecodedMessage<RingBuffer::GetVmoResponse>& _msg);
+ static void StartRequest(const ::fidl::DecodedMessage<RingBuffer::StartRequest>& _msg);
+ static void StartResponse(const ::fidl::DecodedMessage<RingBuffer::StartResponse>& _msg);
+ static void StopRequest(const ::fidl::DecodedMessage<RingBuffer::StopRequest>& _msg);
+ static void StopResponse(const ::fidl::DecodedMessage<RingBuffer::StopResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigGetPropertiesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigGetPropertiesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigGetSupportedFormatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigGetSupportedFormatsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigCreateRingBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigCreateRingBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigWatchGainStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigWatchGainStateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigSetGainRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigSetGainResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigWatchPlugStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_audio_StreamConfigWatchPlugStateResponseTable;
+
+class StreamConfig final {
+ StreamConfig() = delete;
+ public:
+
+ struct GetPropertiesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::audio::StreamProperties properties;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_StreamConfigGetPropertiesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 776;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetPropertiesRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetSupportedFormatsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::audio::SupportedFormats> supported_formats;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_StreamConfigGetSupportedFormatsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 29184;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetSupportedFormatsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct CreateRingBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::audio::Format format;
+ ::zx::channel ring_buffer;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_StreamConfigCreateRingBufferRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 40;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 40;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ struct WatchGainStateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::audio::GainState gain_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_StreamConfigWatchGainStateResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using WatchGainStateRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetGainRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::audio::GainState target_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_StreamConfigSetGainRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 72;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ struct WatchPlugStateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::audio::PlugState plug_state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_audio_StreamConfigWatchPlugStateResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 48;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using WatchPlugStateRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetProperties_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetProperties_Impl(::zx::unowned_channel _client_end);
+ ~GetProperties_Impl() = default;
+ GetProperties_Impl(GetProperties_Impl&& other) = default;
+ GetProperties_Impl& operator=(GetProperties_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 GetSupportedFormats_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSupportedFormats_Impl(::zx::unowned_channel _client_end);
+ ~GetSupportedFormats_Impl() = default;
+ GetSupportedFormats_Impl(GetSupportedFormats_Impl&& other) = default;
+ GetSupportedFormats_Impl& operator=(GetSupportedFormats_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class CreateRingBuffer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CreateRingBuffer_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer);
+ ~CreateRingBuffer_Impl() = default;
+ CreateRingBuffer_Impl(CreateRingBuffer_Impl&& other) = default;
+ CreateRingBuffer_Impl& operator=(CreateRingBuffer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class WatchGainState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WatchGainState_Impl(::zx::unowned_channel _client_end);
+ ~WatchGainState_Impl() = default;
+ WatchGainState_Impl(WatchGainState_Impl&& other) = default;
+ WatchGainState_Impl& operator=(WatchGainState_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class SetGain_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetGain_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::audio::GainState target_state);
+ ~SetGain_Impl() = default;
+ SetGain_Impl(SetGain_Impl&& other) = default;
+ SetGain_Impl& operator=(SetGain_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class WatchPlugState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WatchPlugState_Impl(::zx::unowned_channel _client_end);
+ ~WatchPlugState_Impl() = default;
+ WatchPlugState_Impl(WatchPlugState_Impl&& other) = default;
+ WatchPlugState_Impl& operator=(WatchPlugState_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 GetProperties = GetProperties_Impl<GetPropertiesResponse>;
+ using GetSupportedFormats = GetSupportedFormats_Impl<GetSupportedFormatsResponse>;
+ using CreateRingBuffer = CreateRingBuffer_Impl;
+ using WatchGainState = WatchGainState_Impl<WatchGainStateResponse>;
+ using SetGain = SetGain_Impl;
+ using WatchPlugState = WatchPlugState_Impl<WatchPlugStateResponse>;
+ };
+
+ // 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 GetProperties_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetProperties_Impl() = default;
+ GetProperties_Impl(GetProperties_Impl&& other) = default;
+ GetProperties_Impl& operator=(GetProperties_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 GetSupportedFormats_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSupportedFormats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetSupportedFormats_Impl() = default;
+ GetSupportedFormats_Impl(GetSupportedFormats_Impl&& other) = default;
+ GetSupportedFormats_Impl& operator=(GetSupportedFormats_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class CreateRingBuffer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CreateRingBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer);
+ ~CreateRingBuffer_Impl() = default;
+ CreateRingBuffer_Impl(CreateRingBuffer_Impl&& other) = default;
+ CreateRingBuffer_Impl& operator=(CreateRingBuffer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class WatchGainState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WatchGainState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WatchGainState_Impl() = default;
+ WatchGainState_Impl(WatchGainState_Impl&& other) = default;
+ WatchGainState_Impl& operator=(WatchGainState_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class SetGain_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetGain_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::GainState target_state);
+ ~SetGain_Impl() = default;
+ SetGain_Impl(SetGain_Impl&& other) = default;
+ SetGain_Impl& operator=(SetGain_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class WatchPlugState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WatchPlugState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WatchPlugState_Impl() = default;
+ WatchPlugState_Impl(WatchPlugState_Impl&& other) = default;
+ WatchPlugState_Impl& operator=(WatchPlugState_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 GetProperties = GetProperties_Impl<GetPropertiesResponse>;
+ using GetSupportedFormats = GetSupportedFormats_Impl<GetSupportedFormatsResponse>;
+ using CreateRingBuffer = CreateRingBuffer_Impl;
+ using WatchGainState = WatchGainState_Impl<WatchGainStateResponse>;
+ using SetGain = SetGain_Impl;
+ using WatchPlugState = WatchPlugState_Impl<WatchPlugStateResponse>;
+ };
+
+ 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_; }
+
+ // Retrieves top level static properties.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetProperties GetProperties();
+
+ // Retrieves top level static properties.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetProperties GetProperties(::fidl::BytePart _response_buffer);
+
+ // Gets formats supported by a given driver. When not all combinations supported by the
+ // driver can be described with one |SupportedFormats|, the driver returns more than one
+ // |SupportedFormats| in the returned vector. For example, if one |SupportedFormats| allows
+ // for 32 bits samples at 48KHz, and 16 bits samples at 96KHz, but not 32 bits samples at
+ // 96KHz, then the driver replies with 2 |SupportedFormats|: <<32bits>,<48KHz>> and
+ // <<16bits>,<96KHz>>. For simplicity, this example ignores parameters other than rate and
+ // bits per sample. In the case where the driver supports either 16 or 32 bits samples at
+ // either 48 or 96KHz, the driver would reply with 1 |SupportedFormats|:
+ // <<16bits,32bits>,<48KHz,96KHz>>.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetSupportedFormats GetSupportedFormats();
+
+ // Gets formats supported by a given driver. When not all combinations supported by the
+ // driver can be described with one |SupportedFormats|, the driver returns more than one
+ // |SupportedFormats| in the returned vector. For example, if one |SupportedFormats| allows
+ // for 32 bits samples at 48KHz, and 16 bits samples at 96KHz, but not 32 bits samples at
+ // 96KHz, then the driver replies with 2 |SupportedFormats|: <<32bits>,<48KHz>> and
+ // <<16bits>,<96KHz>>. For simplicity, this example ignores parameters other than rate and
+ // bits per sample. In the case where the driver supports either 16 or 32 bits samples at
+ // either 48 or 96KHz, the driver would reply with 1 |SupportedFormats|:
+ // <<16bits,32bits>,<48KHz,96KHz>>.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSupportedFormats GetSupportedFormats(::fidl::BytePart _response_buffer);
+
+ // |CreateRingBuffer| is sent by clients to select a stream format based on information that
+ // the driver provides in |GetSupportedFormats| what is supported by the client, and any other
+ // requirement. The |ring_buffer| channel is used to control the audio buffer, if a previous
+ // ring buffer channel had been established and was still active, the driver must close that
+ // (ring buffer) channel and make every attempt to gracefully quiesce any on-going streaming
+ // operations in the process.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateRingBuffer CreateRingBuffer(::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer);
+
+ // |CreateRingBuffer| is sent by clients to select a stream format based on information that
+ // the driver provides in |GetSupportedFormats| what is supported by the client, and any other
+ // requirement. The |ring_buffer| channel is used to control the audio buffer, if a previous
+ // ring buffer channel had been established and was still active, the driver must close that
+ // (ring buffer) channel and make every attempt to gracefully quiesce any on-going streaming
+ // operations in the process.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateRingBuffer CreateRingBuffer(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer);
+
+ // Get the gain state via a hanging get. The driver will reply to the first |WatchGainState|
+ // sent by the client. The driver will not respond to subsequent client |WatchGainState| calls
+ // until the gain state changes from what was most recently reported.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::WatchGainState WatchGainState();
+
+ // Get the gain state via a hanging get. The driver will reply to the first |WatchGainState|
+ // sent by the client. The driver will not respond to subsequent client |WatchGainState| calls
+ // until the gain state changes from what was most recently reported.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WatchGainState WatchGainState(::fidl::BytePart _response_buffer);
+
+ // Client update of the gain state.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetGain SetGain(::llcpp::fuchsia::hardware::audio::GainState target_state);
+
+ // Client update of the gain state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetGain SetGain(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::GainState target_state);
+
+ // Get the plug detect state via a hanging get. The driver will reply to the first
+ // |WatchPlugState| sent by the client. The driver will not respond to subsequent client
+ // |WatchPlugState| calls until the plug state changes from what was most recently reported.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::WatchPlugState WatchPlugState();
+
+ // Get the plug detect state via a hanging get. The driver will reply to the first
+ // |WatchPlugState| sent by the client. The driver will not respond to subsequent client
+ // |WatchPlugState| calls until the plug state changes from what was most recently reported.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WatchPlugState WatchPlugState(::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:
+
+ // Retrieves top level static properties.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetProperties GetProperties(::zx::unowned_channel _client_end);
+
+ // Retrieves top level static properties.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetProperties GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Gets formats supported by a given driver. When not all combinations supported by the
+ // driver can be described with one |SupportedFormats|, the driver returns more than one
+ // |SupportedFormats| in the returned vector. For example, if one |SupportedFormats| allows
+ // for 32 bits samples at 48KHz, and 16 bits samples at 96KHz, but not 32 bits samples at
+ // 96KHz, then the driver replies with 2 |SupportedFormats|: <<32bits>,<48KHz>> and
+ // <<16bits>,<96KHz>>. For simplicity, this example ignores parameters other than rate and
+ // bits per sample. In the case where the driver supports either 16 or 32 bits samples at
+ // either 48 or 96KHz, the driver would reply with 1 |SupportedFormats|:
+ // <<16bits,32bits>,<48KHz,96KHz>>.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetSupportedFormats GetSupportedFormats(::zx::unowned_channel _client_end);
+
+ // Gets formats supported by a given driver. When not all combinations supported by the
+ // driver can be described with one |SupportedFormats|, the driver returns more than one
+ // |SupportedFormats| in the returned vector. For example, if one |SupportedFormats| allows
+ // for 32 bits samples at 48KHz, and 16 bits samples at 96KHz, but not 32 bits samples at
+ // 96KHz, then the driver replies with 2 |SupportedFormats|: <<32bits>,<48KHz>> and
+ // <<16bits>,<96KHz>>. For simplicity, this example ignores parameters other than rate and
+ // bits per sample. In the case where the driver supports either 16 or 32 bits samples at
+ // either 48 or 96KHz, the driver would reply with 1 |SupportedFormats|:
+ // <<16bits,32bits>,<48KHz,96KHz>>.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSupportedFormats GetSupportedFormats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // |CreateRingBuffer| is sent by clients to select a stream format based on information that
+ // the driver provides in |GetSupportedFormats| what is supported by the client, and any other
+ // requirement. The |ring_buffer| channel is used to control the audio buffer, if a previous
+ // ring buffer channel had been established and was still active, the driver must close that
+ // (ring buffer) channel and make every attempt to gracefully quiesce any on-going streaming
+ // operations in the process.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateRingBuffer CreateRingBuffer(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer);
+
+ // |CreateRingBuffer| is sent by clients to select a stream format based on information that
+ // the driver provides in |GetSupportedFormats| what is supported by the client, and any other
+ // requirement. The |ring_buffer| channel is used to control the audio buffer, if a previous
+ // ring buffer channel had been established and was still active, the driver must close that
+ // (ring buffer) channel and make every attempt to gracefully quiesce any on-going streaming
+ // operations in the process.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateRingBuffer CreateRingBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer);
+
+ // Get the gain state via a hanging get. The driver will reply to the first |WatchGainState|
+ // sent by the client. The driver will not respond to subsequent client |WatchGainState| calls
+ // until the gain state changes from what was most recently reported.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::WatchGainState WatchGainState(::zx::unowned_channel _client_end);
+
+ // Get the gain state via a hanging get. The driver will reply to the first |WatchGainState|
+ // sent by the client. The driver will not respond to subsequent client |WatchGainState| calls
+ // until the gain state changes from what was most recently reported.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WatchGainState WatchGainState(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Client update of the gain state.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetGain SetGain(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::audio::GainState target_state);
+
+ // Client update of the gain state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetGain SetGain(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::audio::GainState target_state);
+
+ // Get the plug detect state via a hanging get. The driver will reply to the first
+ // |WatchPlugState| sent by the client. The driver will not respond to subsequent client
+ // |WatchPlugState| calls until the plug state changes from what was most recently reported.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::WatchPlugState WatchPlugState(::zx::unowned_channel _client_end);
+
+ // Get the plug detect state via a hanging get. The driver will reply to the first
+ // |WatchPlugState| sent by the client. The driver will not respond to subsequent client
+ // |WatchPlugState| calls until the plug state changes from what was most recently reported.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WatchPlugState WatchPlugState(::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:
+
+ // Retrieves top level static properties.
+ static ::fidl::DecodeResult<GetPropertiesResponse> GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Gets formats supported by a given driver. When not all combinations supported by the
+ // driver can be described with one |SupportedFormats|, the driver returns more than one
+ // |SupportedFormats| in the returned vector. For example, if one |SupportedFormats| allows
+ // for 32 bits samples at 48KHz, and 16 bits samples at 96KHz, but not 32 bits samples at
+ // 96KHz, then the driver replies with 2 |SupportedFormats|: <<32bits>,<48KHz>> and
+ // <<16bits>,<96KHz>>. For simplicity, this example ignores parameters other than rate and
+ // bits per sample. In the case where the driver supports either 16 or 32 bits samples at
+ // either 48 or 96KHz, the driver would reply with 1 |SupportedFormats|:
+ // <<16bits,32bits>,<48KHz,96KHz>>.
+ static ::fidl::DecodeResult<GetSupportedFormatsResponse> GetSupportedFormats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // |CreateRingBuffer| is sent by clients to select a stream format based on information that
+ // the driver provides in |GetSupportedFormats| what is supported by the client, and any other
+ // requirement. The |ring_buffer| channel is used to control the audio buffer, if a previous
+ // ring buffer channel had been established and was still active, the driver must close that
+ // (ring buffer) channel and make every attempt to gracefully quiesce any on-going streaming
+ // operations in the process.
+ static ::fidl::internal::StatusAndError CreateRingBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateRingBufferRequest> params);
+
+ // Get the gain state via a hanging get. The driver will reply to the first |WatchGainState|
+ // sent by the client. The driver will not respond to subsequent client |WatchGainState| calls
+ // until the gain state changes from what was most recently reported.
+ static ::fidl::DecodeResult<WatchGainStateResponse> WatchGainState(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Client update of the gain state.
+ static ::fidl::internal::StatusAndError SetGain(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetGainRequest> params);
+
+ // Get the plug detect state via a hanging get. The driver will reply to the first
+ // |WatchPlugState| sent by the client. The driver will not respond to subsequent client
+ // |WatchPlugState| calls until the plug state changes from what was most recently reported.
+ static ::fidl::DecodeResult<WatchPlugStateResponse> WatchPlugState(::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 = StreamConfig;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetPropertiesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::audio::StreamProperties properties);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::StreamProperties properties);
+ void Reply(::fidl::DecodedMessage<GetPropertiesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPropertiesCompleter = ::fidl::Completer<GetPropertiesCompleterBase>;
+
+ virtual void GetProperties(GetPropertiesCompleter::Sync _completer) = 0;
+
+ class GetSupportedFormatsCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::hardware::audio::SupportedFormats> supported_formats);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::hardware::audio::SupportedFormats> supported_formats);
+ void Reply(::fidl::DecodedMessage<GetSupportedFormatsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSupportedFormatsCompleter = ::fidl::Completer<GetSupportedFormatsCompleterBase>;
+
+ virtual void GetSupportedFormats(GetSupportedFormatsCompleter::Sync _completer) = 0;
+
+ using CreateRingBufferCompleter = ::fidl::Completer<>;
+
+ virtual void CreateRingBuffer(::llcpp::fuchsia::hardware::audio::Format format, ::zx::channel ring_buffer, CreateRingBufferCompleter::Sync _completer) = 0;
+
+ class WatchGainStateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::audio::GainState gain_state);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::GainState gain_state);
+ void Reply(::fidl::DecodedMessage<WatchGainStateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchGainStateCompleter = ::fidl::Completer<WatchGainStateCompleterBase>;
+
+ virtual void WatchGainState(WatchGainStateCompleter::Sync _completer) = 0;
+
+ using SetGainCompleter = ::fidl::Completer<>;
+
+ virtual void SetGain(::llcpp::fuchsia::hardware::audio::GainState target_state, SetGainCompleter::Sync _completer) = 0;
+
+ class WatchPlugStateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::audio::PlugState plug_state);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::audio::PlugState plug_state);
+ void Reply(::fidl::DecodedMessage<WatchPlugStateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchPlugStateCompleter = ::fidl::Completer<WatchPlugStateCompleterBase>;
+
+ virtual void WatchPlugState(WatchPlugStateCompleter::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 GetPropertiesRequest(const ::fidl::DecodedMessage<StreamConfig::GetPropertiesRequest>& _msg);
+ static void GetPropertiesResponse(const ::fidl::DecodedMessage<StreamConfig::GetPropertiesResponse>& _msg);
+ static void GetSupportedFormatsRequest(const ::fidl::DecodedMessage<StreamConfig::GetSupportedFormatsRequest>& _msg);
+ static void GetSupportedFormatsResponse(const ::fidl::DecodedMessage<StreamConfig::GetSupportedFormatsResponse>& _msg);
+ static void CreateRingBufferRequest(const ::fidl::DecodedMessage<StreamConfig::CreateRingBufferRequest>& _msg);
+ static void WatchGainStateRequest(const ::fidl::DecodedMessage<StreamConfig::WatchGainStateRequest>& _msg);
+ static void WatchGainStateResponse(const ::fidl::DecodedMessage<StreamConfig::WatchGainStateResponse>& _msg);
+ static void SetGainRequest(const ::fidl::DecodedMessage<StreamConfig::SetGainRequest>& _msg);
+ static void WatchPlugStateRequest(const ::fidl::DecodedMessage<StreamConfig::WatchPlugStateRequest>& _msg);
+ static void WatchPlugStateResponse(const ::fidl::DecodedMessage<StreamConfig::WatchPlugStateResponse>& _msg);
+ };
+};
+
+} // namespace audio
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo, timestamp) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo, position) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo) == ::llcpp::fuchsia::hardware::audio::RingBufferPositionInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::PlugState> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::PlugState>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBufferProperties> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::RingBufferProperties>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::Device::GetChannelResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::Device::GetChannelResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::Device::GetChannelResponse)
+ == ::llcpp::fuchsia::hardware::audio::Device::GetChannelResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::Device::GetChannelResponse, channel) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::PcmSupportedFormats> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::PcmSupportedFormats>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmSupportedFormats, number_of_channels) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmSupportedFormats, sample_formats) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmSupportedFormats, bytes_per_sample) == 32);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmSupportedFormats, valid_bits_per_sample) == 48);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmSupportedFormats, frame_rates) == 64);
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::PcmSupportedFormats) == ::llcpp::fuchsia::hardware::audio::PcmSupportedFormats::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::SupportedFormats> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::SupportedFormats>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::PcmFormat> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::PcmFormat>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmFormat, number_of_channels) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmFormat, channels_to_use_bitmask) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmFormat, sample_format) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmFormat, bytes_per_sample) == 17);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmFormat, valid_bits_per_sample) == 18);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::PcmFormat, frame_rate) == 20);
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::PcmFormat) == ::llcpp::fuchsia::hardware::audio::PcmFormat::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::Format> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::Format>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response, num_frames) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response, ring_buffer) == 4);
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response) == ::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::StreamProperties> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::StreamProperties>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::RingBuffer_GetVmo_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBuffer::GetPropertiesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::RingBuffer::GetPropertiesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::RingBuffer::GetPropertiesResponse)
+ == ::llcpp::fuchsia::hardware::audio::RingBuffer::GetPropertiesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBuffer::GetPropertiesResponse, properties) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBuffer::WatchClockRecoveryPositionInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::RingBuffer::WatchClockRecoveryPositionInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::RingBuffer::WatchClockRecoveryPositionInfoResponse)
+ == ::llcpp::fuchsia::hardware::audio::RingBuffer::WatchClockRecoveryPositionInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBuffer::WatchClockRecoveryPositionInfoResponse, position_info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoRequest)
+ == ::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoRequest, min_frames) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoRequest, clock_recovery_notifications_per_ring) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoResponse)
+ == ::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBuffer::GetVmoResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::RingBuffer::StartResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::RingBuffer::StartResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::RingBuffer::StartResponse)
+ == ::llcpp::fuchsia::hardware::audio::RingBuffer::StartResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::RingBuffer::StartResponse, start_time) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::GainState> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::audio::GainState>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::StreamConfig::GetPropertiesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::StreamConfig::GetPropertiesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::StreamConfig::GetPropertiesResponse)
+ == ::llcpp::fuchsia::hardware::audio::StreamConfig::GetPropertiesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::StreamConfig::GetPropertiesResponse, properties) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::StreamConfig::GetSupportedFormatsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::StreamConfig::GetSupportedFormatsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::StreamConfig::GetSupportedFormatsResponse)
+ == ::llcpp::fuchsia::hardware::audio::StreamConfig::GetSupportedFormatsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::StreamConfig::GetSupportedFormatsResponse, supported_formats) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::StreamConfig::CreateRingBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::StreamConfig::CreateRingBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::StreamConfig::CreateRingBufferRequest)
+ == ::llcpp::fuchsia::hardware::audio::StreamConfig::CreateRingBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::StreamConfig::CreateRingBufferRequest, format) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::StreamConfig::CreateRingBufferRequest, ring_buffer) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::StreamConfig::WatchGainStateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::StreamConfig::WatchGainStateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::StreamConfig::WatchGainStateResponse)
+ == ::llcpp::fuchsia::hardware::audio::StreamConfig::WatchGainStateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::StreamConfig::WatchGainStateResponse, gain_state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::StreamConfig::SetGainRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::StreamConfig::SetGainRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::StreamConfig::SetGainRequest)
+ == ::llcpp::fuchsia::hardware::audio::StreamConfig::SetGainRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::StreamConfig::SetGainRequest, target_state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::audio::StreamConfig::WatchPlugStateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::audio::StreamConfig::WatchPlugStateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::audio::StreamConfig::WatchPlugStateResponse)
+ == ::llcpp::fuchsia::hardware::audio::StreamConfig::WatchPlugStateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::audio::StreamConfig::WatchPlugStateResponse, plug_state) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-backlight/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-backlight/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..09b10cc
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-backlight/gen/llcpp/fidl.cc
@@ -0,0 +1,820 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/backlight/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace backlight {
+
+void ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Device_GetStateNormalized_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Device_GetStateNormalized_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Device_GetStateNormalized_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Device_GetStateAbsolute_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Device_GetStateAbsolute_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Device_GetStateAbsolute_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Device_SetStateNormalized_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Device_SetStateNormalized_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Device_SetStateNormalized_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Device_SetStateAbsolute_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Device_SetStateAbsolute_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Device_SetStateAbsolute_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Device_GetMaxAbsoluteBrightness_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Device_GetMaxAbsoluteBrightness_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Device_GetMaxAbsoluteBrightness_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStateNormalized_Ordinal = 0x44ba72a000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStateNormalized_GenOrdinal = 0x2506201b5999b9b7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateNormalizedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateNormalizedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetStateNormalized_Ordinal = 0xc19adb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetStateNormalized_GenOrdinal = 0x554ac5cb4f9f5b62lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateNormalizedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateNormalizedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStateAbsolute_Ordinal = 0x971592f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStateAbsolute_GenOrdinal = 0x1f8ccf01cf526a2blu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateAbsoluteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateAbsoluteResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetStateAbsolute_Ordinal = 0x697f353e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetStateAbsolute_GenOrdinal = 0x19c100c43faaa178lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateAbsoluteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateAbsoluteResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetMaxAbsoluteBrightness_Ordinal = 0x65fe16500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetMaxAbsoluteBrightness_GenOrdinal = 0x2aa0699313d4160dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetMaxAbsoluteBrightnessRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetMaxAbsoluteBrightnessResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetStateNormalized_Impl<Device::GetStateNormalizedResponse>::GetStateNormalized_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateNormalizedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStateNormalizedRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStateNormalizedRequest));
+ ::fidl::DecodedMessage<GetStateNormalizedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetStateNormalized(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetStateNormalized Device::SyncClient::GetStateNormalized() {
+ return ResultOf::GetStateNormalized(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetStateNormalized Device::Call::GetStateNormalized(::zx::unowned_channel _client_end) {
+ return ResultOf::GetStateNormalized(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetStateNormalized_Impl<Device::GetStateNormalizedResponse>::GetStateNormalized_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetStateNormalizedRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetStateNormalizedRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetStateNormalizedRequest));
+ ::fidl::DecodedMessage<GetStateNormalizedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetStateNormalized(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetStateNormalized Device::SyncClient::GetStateNormalized(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStateNormalized(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetStateNormalized Device::Call::GetStateNormalized(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStateNormalized(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetStateNormalizedResponse> Device::InPlace::GetStateNormalized(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetStateNormalizedRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetStateNormalizedRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetStateNormalizedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStateNormalizedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStateNormalizedRequest, GetStateNormalizedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStateNormalizedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetStateNormalized_Impl<Device::SetStateNormalizedResponse>::SetStateNormalized_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateNormalizedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetStateNormalizedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetStateNormalizedRequest*>(_write_bytes);
+ _request.state = std::move(state);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetStateNormalizedRequest));
+ ::fidl::DecodedMessage<SetStateNormalizedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetStateNormalized(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetStateNormalized Device::SyncClient::SetStateNormalized(::llcpp::fuchsia::hardware::backlight::State state) {
+ return ResultOf::SetStateNormalized(::zx::unowned_channel(this->channel_), std::move(state));
+}
+
+Device::ResultOf::SetStateNormalized Device::Call::SetStateNormalized(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state) {
+ return ResultOf::SetStateNormalized(std::move(_client_end), std::move(state));
+}
+
+template <>
+Device::UnownedResultOf::SetStateNormalized_Impl<Device::SetStateNormalizedResponse>::SetStateNormalized_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetStateNormalizedRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetStateNormalizedResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetStateNormalizedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetStateNormalizedRequest*>(_request_buffer.data());
+ _request.state = std::move(state);
+ _request_buffer.set_actual(sizeof(SetStateNormalizedRequest));
+ ::fidl::DecodedMessage<SetStateNormalizedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetStateNormalized(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetStateNormalized Device::SyncClient::SetStateNormalized(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetStateNormalized(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetStateNormalized Device::Call::SetStateNormalized(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetStateNormalized(std::move(_client_end), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetStateNormalizedResponse> Device::InPlace::SetStateNormalized(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetStateNormalizedRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetStateNormalizedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetStateNormalizedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetStateNormalizedRequest, SetStateNormalizedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetStateNormalizedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetStateAbsolute_Impl<Device::GetStateAbsoluteResponse>::GetStateAbsolute_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateAbsoluteRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStateAbsoluteRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStateAbsoluteRequest));
+ ::fidl::DecodedMessage<GetStateAbsoluteRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetStateAbsolute(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetStateAbsolute Device::SyncClient::GetStateAbsolute() {
+ return ResultOf::GetStateAbsolute(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetStateAbsolute Device::Call::GetStateAbsolute(::zx::unowned_channel _client_end) {
+ return ResultOf::GetStateAbsolute(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetStateAbsolute_Impl<Device::GetStateAbsoluteResponse>::GetStateAbsolute_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetStateAbsoluteRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetStateAbsoluteRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetStateAbsoluteRequest));
+ ::fidl::DecodedMessage<GetStateAbsoluteRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetStateAbsolute(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetStateAbsolute Device::SyncClient::GetStateAbsolute(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStateAbsolute(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetStateAbsolute Device::Call::GetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStateAbsolute(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetStateAbsoluteResponse> Device::InPlace::GetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetStateAbsoluteRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetStateAbsoluteRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetStateAbsoluteRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStateAbsoluteResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStateAbsoluteRequest, GetStateAbsoluteResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStateAbsoluteResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetStateAbsolute_Impl<Device::SetStateAbsoluteResponse>::SetStateAbsolute_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateAbsoluteRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetStateAbsoluteRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetStateAbsoluteRequest*>(_write_bytes);
+ _request.state = std::move(state);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetStateAbsoluteRequest));
+ ::fidl::DecodedMessage<SetStateAbsoluteRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetStateAbsolute(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetStateAbsolute Device::SyncClient::SetStateAbsolute(::llcpp::fuchsia::hardware::backlight::State state) {
+ return ResultOf::SetStateAbsolute(::zx::unowned_channel(this->channel_), std::move(state));
+}
+
+Device::ResultOf::SetStateAbsolute Device::Call::SetStateAbsolute(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state) {
+ return ResultOf::SetStateAbsolute(std::move(_client_end), std::move(state));
+}
+
+template <>
+Device::UnownedResultOf::SetStateAbsolute_Impl<Device::SetStateAbsoluteResponse>::SetStateAbsolute_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetStateAbsoluteRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetStateAbsoluteResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetStateAbsoluteRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetStateAbsoluteRequest*>(_request_buffer.data());
+ _request.state = std::move(state);
+ _request_buffer.set_actual(sizeof(SetStateAbsoluteRequest));
+ ::fidl::DecodedMessage<SetStateAbsoluteRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetStateAbsolute(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetStateAbsolute Device::SyncClient::SetStateAbsolute(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetStateAbsolute(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetStateAbsolute Device::Call::SetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetStateAbsolute(std::move(_client_end), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetStateAbsoluteResponse> Device::InPlace::SetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetStateAbsoluteRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetStateAbsoluteRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetStateAbsoluteResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetStateAbsoluteRequest, SetStateAbsoluteResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetStateAbsoluteResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetMaxAbsoluteBrightness_Impl<Device::GetMaxAbsoluteBrightnessResponse>::GetMaxAbsoluteBrightness_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMaxAbsoluteBrightnessRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetMaxAbsoluteBrightnessRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMaxAbsoluteBrightnessRequest));
+ ::fidl::DecodedMessage<GetMaxAbsoluteBrightnessRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetMaxAbsoluteBrightness(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetMaxAbsoluteBrightness Device::SyncClient::GetMaxAbsoluteBrightness() {
+ return ResultOf::GetMaxAbsoluteBrightness(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetMaxAbsoluteBrightness Device::Call::GetMaxAbsoluteBrightness(::zx::unowned_channel _client_end) {
+ return ResultOf::GetMaxAbsoluteBrightness(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetMaxAbsoluteBrightness_Impl<Device::GetMaxAbsoluteBrightnessResponse>::GetMaxAbsoluteBrightness_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetMaxAbsoluteBrightnessRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetMaxAbsoluteBrightnessRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetMaxAbsoluteBrightnessRequest));
+ ::fidl::DecodedMessage<GetMaxAbsoluteBrightnessRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetMaxAbsoluteBrightness(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetMaxAbsoluteBrightness Device::SyncClient::GetMaxAbsoluteBrightness(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMaxAbsoluteBrightness(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetMaxAbsoluteBrightness Device::Call::GetMaxAbsoluteBrightness(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMaxAbsoluteBrightness(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetMaxAbsoluteBrightnessResponse> Device::InPlace::GetMaxAbsoluteBrightness(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetMaxAbsoluteBrightnessRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetMaxAbsoluteBrightnessRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetMaxAbsoluteBrightnessRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetMaxAbsoluteBrightnessResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetMaxAbsoluteBrightnessRequest, GetMaxAbsoluteBrightnessResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetMaxAbsoluteBrightnessResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetStateNormalized_Ordinal:
+ case kDevice_GetStateNormalized_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStateNormalizedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetStateNormalized(
+ Interface::GetStateNormalizedCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetStateNormalized_Ordinal:
+ case kDevice_SetStateNormalized_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetStateNormalizedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetStateNormalized(std::move(message->state),
+ Interface::SetStateNormalizedCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetStateAbsolute_Ordinal:
+ case kDevice_GetStateAbsolute_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStateAbsoluteRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetStateAbsolute(
+ Interface::GetStateAbsoluteCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetStateAbsolute_Ordinal:
+ case kDevice_SetStateAbsolute_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetStateAbsoluteRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetStateAbsolute(std::move(message->state),
+ Interface::SetStateAbsoluteCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetMaxAbsoluteBrightness_Ordinal:
+ case kDevice_GetMaxAbsoluteBrightness_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetMaxAbsoluteBrightnessRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetMaxAbsoluteBrightness(
+ Interface::GetMaxAbsoluteBrightnessCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetStateNormalizedCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateNormalizedResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetStateNormalizedResponse _response = {};
+ Device::SetTransactionHeaderFor::GetStateNormalizedResponse(
+ ::fidl::DecodedMessage<GetStateNormalizedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateNormalizedResponse::PrimarySize,
+ GetStateNormalizedResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::GetStateNormalizedCompleterBase::ReplySuccess(::llcpp::fuchsia::hardware::backlight::State state) {
+ Device_GetStateNormalized_Response response;
+ response.state = std::move(state);
+
+ Reply(Device_GetStateNormalized_Result::WithResponse(&response));
+}
+void Device::Interface::GetStateNormalizedCompleterBase::ReplyError(int32_t error) {
+ Reply(Device_GetStateNormalized_Result::WithErr(&error));
+}
+
+void Device::Interface::GetStateNormalizedCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result result) {
+ if (_buffer.capacity() < GetStateNormalizedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetStateNormalizedResponse _response = {};
+ Device::SetTransactionHeaderFor::GetStateNormalizedResponse(
+ ::fidl::DecodedMessage<GetStateNormalizedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateNormalizedResponse::PrimarySize,
+ GetStateNormalizedResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::GetStateNormalizedCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::State state) {
+ Device_GetStateNormalized_Response response;
+ response.state = std::move(state);
+
+ Reply(std::move(_buffer), Device_GetStateNormalized_Result::WithResponse(&response));
+}
+
+void Device::Interface::GetStateNormalizedCompleterBase::Reply(::fidl::DecodedMessage<GetStateNormalizedResponse> params) {
+ Device::SetTransactionHeaderFor::GetStateNormalizedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetStateNormalizedCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateNormalizedResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SetStateNormalizedResponse _response = {};
+ Device::SetTransactionHeaderFor::SetStateNormalizedResponse(
+ ::fidl::DecodedMessage<SetStateNormalizedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetStateNormalizedResponse::PrimarySize,
+ SetStateNormalizedResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::SetStateNormalizedCompleterBase::ReplySuccess() {
+ Device_SetStateNormalized_Response response;
+
+ Reply(Device_SetStateNormalized_Result::WithResponse(&response));
+}
+void Device::Interface::SetStateNormalizedCompleterBase::ReplyError(int32_t error) {
+ Reply(Device_SetStateNormalized_Result::WithErr(&error));
+}
+
+void Device::Interface::SetStateNormalizedCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result result) {
+ if (_buffer.capacity() < SetStateNormalizedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SetStateNormalizedResponse _response = {};
+ Device::SetTransactionHeaderFor::SetStateNormalizedResponse(
+ ::fidl::DecodedMessage<SetStateNormalizedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetStateNormalizedResponse::PrimarySize,
+ SetStateNormalizedResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::SetStateNormalizedCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Device_SetStateNormalized_Response response;
+
+ Reply(std::move(_buffer), Device_SetStateNormalized_Result::WithResponse(&response));
+}
+
+void Device::Interface::SetStateNormalizedCompleterBase::Reply(::fidl::DecodedMessage<SetStateNormalizedResponse> params) {
+ Device::SetTransactionHeaderFor::SetStateNormalizedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetStateAbsoluteCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateAbsoluteResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetStateAbsoluteResponse _response = {};
+ Device::SetTransactionHeaderFor::GetStateAbsoluteResponse(
+ ::fidl::DecodedMessage<GetStateAbsoluteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateAbsoluteResponse::PrimarySize,
+ GetStateAbsoluteResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::GetStateAbsoluteCompleterBase::ReplySuccess(::llcpp::fuchsia::hardware::backlight::State state) {
+ Device_GetStateAbsolute_Response response;
+ response.state = std::move(state);
+
+ Reply(Device_GetStateAbsolute_Result::WithResponse(&response));
+}
+void Device::Interface::GetStateAbsoluteCompleterBase::ReplyError(int32_t error) {
+ Reply(Device_GetStateAbsolute_Result::WithErr(&error));
+}
+
+void Device::Interface::GetStateAbsoluteCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result result) {
+ if (_buffer.capacity() < GetStateAbsoluteResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetStateAbsoluteResponse _response = {};
+ Device::SetTransactionHeaderFor::GetStateAbsoluteResponse(
+ ::fidl::DecodedMessage<GetStateAbsoluteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateAbsoluteResponse::PrimarySize,
+ GetStateAbsoluteResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::GetStateAbsoluteCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::State state) {
+ Device_GetStateAbsolute_Response response;
+ response.state = std::move(state);
+
+ Reply(std::move(_buffer), Device_GetStateAbsolute_Result::WithResponse(&response));
+}
+
+void Device::Interface::GetStateAbsoluteCompleterBase::Reply(::fidl::DecodedMessage<GetStateAbsoluteResponse> params) {
+ Device::SetTransactionHeaderFor::GetStateAbsoluteResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetStateAbsoluteCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateAbsoluteResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SetStateAbsoluteResponse _response = {};
+ Device::SetTransactionHeaderFor::SetStateAbsoluteResponse(
+ ::fidl::DecodedMessage<SetStateAbsoluteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetStateAbsoluteResponse::PrimarySize,
+ SetStateAbsoluteResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::SetStateAbsoluteCompleterBase::ReplySuccess() {
+ Device_SetStateAbsolute_Response response;
+
+ Reply(Device_SetStateAbsolute_Result::WithResponse(&response));
+}
+void Device::Interface::SetStateAbsoluteCompleterBase::ReplyError(int32_t error) {
+ Reply(Device_SetStateAbsolute_Result::WithErr(&error));
+}
+
+void Device::Interface::SetStateAbsoluteCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result result) {
+ if (_buffer.capacity() < SetStateAbsoluteResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SetStateAbsoluteResponse _response = {};
+ Device::SetTransactionHeaderFor::SetStateAbsoluteResponse(
+ ::fidl::DecodedMessage<SetStateAbsoluteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetStateAbsoluteResponse::PrimarySize,
+ SetStateAbsoluteResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::SetStateAbsoluteCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Device_SetStateAbsolute_Response response;
+
+ Reply(std::move(_buffer), Device_SetStateAbsolute_Result::WithResponse(&response));
+}
+
+void Device::Interface::SetStateAbsoluteCompleterBase::Reply(::fidl::DecodedMessage<SetStateAbsoluteResponse> params) {
+ Device::SetTransactionHeaderFor::SetStateAbsoluteResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::Reply(::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMaxAbsoluteBrightnessResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetMaxAbsoluteBrightnessResponse _response = {};
+ Device::SetTransactionHeaderFor::GetMaxAbsoluteBrightnessResponse(
+ ::fidl::DecodedMessage<GetMaxAbsoluteBrightnessResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMaxAbsoluteBrightnessResponse::PrimarySize,
+ GetMaxAbsoluteBrightnessResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::ReplySuccess(double max_brightness) {
+ Device_GetMaxAbsoluteBrightness_Response response;
+ response.max_brightness = std::move(max_brightness);
+
+ Reply(Device_GetMaxAbsoluteBrightness_Result::WithResponse(&response));
+}
+void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::ReplyError(int32_t error) {
+ Reply(Device_GetMaxAbsoluteBrightness_Result::WithErr(&error));
+}
+
+void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result result) {
+ if (_buffer.capacity() < GetMaxAbsoluteBrightnessResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetMaxAbsoluteBrightnessResponse _response = {};
+ Device::SetTransactionHeaderFor::GetMaxAbsoluteBrightnessResponse(
+ ::fidl::DecodedMessage<GetMaxAbsoluteBrightnessResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMaxAbsoluteBrightnessResponse::PrimarySize,
+ GetMaxAbsoluteBrightnessResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::ReplySuccess(::fidl::BytePart _buffer, double max_brightness) {
+ Device_GetMaxAbsoluteBrightness_Response response;
+ response.max_brightness = std::move(max_brightness);
+
+ Reply(std::move(_buffer), Device_GetMaxAbsoluteBrightness_Result::WithResponse(&response));
+}
+
+void Device::Interface::GetMaxAbsoluteBrightnessCompleterBase::Reply(::fidl::DecodedMessage<GetMaxAbsoluteBrightnessResponse> params) {
+ Device::SetTransactionHeaderFor::GetMaxAbsoluteBrightnessResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetStateNormalizedRequest(const ::fidl::DecodedMessage<Device::GetStateNormalizedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStateNormalized_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetStateNormalizedResponse(const ::fidl::DecodedMessage<Device::GetStateNormalizedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStateNormalized_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetStateNormalizedRequest(const ::fidl::DecodedMessage<Device::SetStateNormalizedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetStateNormalized_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetStateNormalizedResponse(const ::fidl::DecodedMessage<Device::SetStateNormalizedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetStateNormalized_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetStateAbsoluteRequest(const ::fidl::DecodedMessage<Device::GetStateAbsoluteRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStateAbsolute_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetStateAbsoluteResponse(const ::fidl::DecodedMessage<Device::GetStateAbsoluteResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStateAbsolute_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetStateAbsoluteRequest(const ::fidl::DecodedMessage<Device::SetStateAbsoluteRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetStateAbsolute_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetStateAbsoluteResponse(const ::fidl::DecodedMessage<Device::SetStateAbsoluteResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetStateAbsolute_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetMaxAbsoluteBrightnessRequest(const ::fidl::DecodedMessage<Device::GetMaxAbsoluteBrightnessRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetMaxAbsoluteBrightness_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetMaxAbsoluteBrightnessResponse(const ::fidl::DecodedMessage<Device::GetMaxAbsoluteBrightnessResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetMaxAbsoluteBrightness_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace backlight
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-backlight/gen/llcpp/include/fuchsia/hardware/backlight/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-backlight/gen/llcpp/include/fuchsia/hardware/backlight/llcpp/fidl.h
new file mode 100644
index 0000000..994c635
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-backlight/gen/llcpp/include/fuchsia/hardware/backlight/llcpp/fidl.h
@@ -0,0 +1,1259 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace backlight {
+
+struct State;
+struct Device_GetStateNormalized_Response;
+struct Device_GetStateNormalized_Result;
+struct Device_GetStateAbsolute_Response;
+struct Device_GetStateAbsolute_Result;
+struct Device_SetStateNormalized_Response;
+struct Device_SetStateNormalized_Result;
+struct Device_SetStateAbsolute_Response;
+struct Device_SetStateAbsolute_Result;
+struct Device_GetMaxAbsoluteBrightness_Response;
+struct Device_GetMaxAbsoluteBrightness_Result;
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_GetStateNormalized_ResultTable;
+
+struct Device_GetStateNormalized_Result {
+ Device_GetStateNormalized_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Device_GetStateNormalized_Result WithResponse(::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response* val) {
+ Device_GetStateNormalized_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Device_GetStateNormalized_Result WithErr(int32_t* val) {
+ Device_GetStateNormalized_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_GetStateNormalized_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_GetStateAbsolute_ResultTable;
+
+struct Device_GetStateAbsolute_Result {
+ Device_GetStateAbsolute_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Device_GetStateAbsolute_Result WithResponse(::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response* val) {
+ Device_GetStateAbsolute_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Device_GetStateAbsolute_Result WithErr(int32_t* val) {
+ Device_GetStateAbsolute_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_GetStateAbsolute_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_SetStateNormalized_ResultTable;
+
+struct Device_SetStateNormalized_Result {
+ Device_SetStateNormalized_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Device_SetStateNormalized_Result WithResponse(::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response* val) {
+ Device_SetStateNormalized_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Device_SetStateNormalized_Result WithErr(int32_t* val) {
+ Device_SetStateNormalized_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_SetStateNormalized_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_SetStateAbsolute_ResultTable;
+
+struct Device_SetStateAbsolute_Result {
+ Device_SetStateAbsolute_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Device_SetStateAbsolute_Result WithResponse(::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response* val) {
+ Device_SetStateAbsolute_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Device_SetStateAbsolute_Result WithErr(int32_t* val) {
+ Device_SetStateAbsolute_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_SetStateAbsolute_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_GetMaxAbsoluteBrightness_ResultTable;
+
+struct Device_GetMaxAbsoluteBrightness_Result {
+ Device_GetMaxAbsoluteBrightness_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Device_GetMaxAbsoluteBrightness_Result WithResponse(::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response* val) {
+ Device_GetMaxAbsoluteBrightness_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Device_GetMaxAbsoluteBrightness_Result WithErr(int32_t* val) {
+ Device_GetMaxAbsoluteBrightness_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_GetMaxAbsoluteBrightness_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_StateTable;
+
+struct State {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_StateTable;
+ 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 backlight_on = {};
+
+ // |brightness| can either be:
+ // 1. The unitless brightness value on a linear scale where 0.0 is the minimum
+ // brightness and 1.0 is the maximum brightness - represents the current /
+ // desired brightness as a percentage within the supported range. Used
+ // by the |GetStateNormalized| / |SetStateNormalized| calls.
+ // 2. Absolute brightness in nits. Used by the |GetStateAbsolute| /
+ // |SetStateAbsolute| calls.
+ double brightness = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_GetStateNormalized_ResponseTable;
+
+struct Device_GetStateNormalized_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_GetStateNormalized_ResponseTable;
+ 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;
+
+ ::llcpp::fuchsia::hardware::backlight::State state = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_GetStateAbsolute_ResponseTable;
+
+struct Device_GetStateAbsolute_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_GetStateAbsolute_ResponseTable;
+ 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;
+
+ ::llcpp::fuchsia::hardware::backlight::State state = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_SetStateNormalized_ResponseTable;
+
+struct Device_SetStateNormalized_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_SetStateNormalized_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_SetStateAbsolute_ResponseTable;
+
+struct Device_SetStateAbsolute_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_SetStateAbsolute_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_Device_GetMaxAbsoluteBrightness_ResponseTable;
+
+struct Device_GetMaxAbsoluteBrightness_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_Device_GetMaxAbsoluteBrightness_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ double max_brightness = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateNormalizedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateNormalizedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateNormalizedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateNormalizedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateAbsoluteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetStateAbsoluteResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateAbsoluteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceSetStateAbsoluteResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetMaxAbsoluteBrightnessRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_backlight_DeviceGetMaxAbsoluteBrightnessResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetStateNormalizedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_DeviceGetStateNormalizedResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetStateNormalizedRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetStateNormalizedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_DeviceSetStateNormalizedResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SetStateNormalizedRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::backlight::State state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_DeviceSetStateNormalizedRequestTable;
+ 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 = SetStateNormalizedResponse;
+ };
+
+ struct GetStateAbsoluteResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_DeviceGetStateAbsoluteResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetStateAbsoluteRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetStateAbsoluteResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_DeviceSetStateAbsoluteResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SetStateAbsoluteRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::backlight::State state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_DeviceSetStateAbsoluteRequestTable;
+ 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 = SetStateAbsoluteResponse;
+ };
+
+ struct GetMaxAbsoluteBrightnessResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_backlight_DeviceGetMaxAbsoluteBrightnessResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetMaxAbsoluteBrightnessRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetStateNormalized_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetStateNormalized_Impl(::zx::unowned_channel _client_end);
+ ~GetStateNormalized_Impl() = default;
+ GetStateNormalized_Impl(GetStateNormalized_Impl&& other) = default;
+ GetStateNormalized_Impl& operator=(GetStateNormalized_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 SetStateNormalized_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetStateNormalized_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state);
+ ~SetStateNormalized_Impl() = default;
+ SetStateNormalized_Impl(SetStateNormalized_Impl&& other) = default;
+ SetStateNormalized_Impl& operator=(SetStateNormalized_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 GetStateAbsolute_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetStateAbsolute_Impl(::zx::unowned_channel _client_end);
+ ~GetStateAbsolute_Impl() = default;
+ GetStateAbsolute_Impl(GetStateAbsolute_Impl&& other) = default;
+ GetStateAbsolute_Impl& operator=(GetStateAbsolute_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 SetStateAbsolute_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetStateAbsolute_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state);
+ ~SetStateAbsolute_Impl() = default;
+ SetStateAbsolute_Impl(SetStateAbsolute_Impl&& other) = default;
+ SetStateAbsolute_Impl& operator=(SetStateAbsolute_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 GetMaxAbsoluteBrightness_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetMaxAbsoluteBrightness_Impl(::zx::unowned_channel _client_end);
+ ~GetMaxAbsoluteBrightness_Impl() = default;
+ GetMaxAbsoluteBrightness_Impl(GetMaxAbsoluteBrightness_Impl&& other) = default;
+ GetMaxAbsoluteBrightness_Impl& operator=(GetMaxAbsoluteBrightness_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 GetStateNormalized = GetStateNormalized_Impl<GetStateNormalizedResponse>;
+ using SetStateNormalized = SetStateNormalized_Impl<SetStateNormalizedResponse>;
+ using GetStateAbsolute = GetStateAbsolute_Impl<GetStateAbsoluteResponse>;
+ using SetStateAbsolute = SetStateAbsolute_Impl<SetStateAbsoluteResponse>;
+ using GetMaxAbsoluteBrightness = GetMaxAbsoluteBrightness_Impl<GetMaxAbsoluteBrightnessResponse>;
+ };
+
+ // 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 GetStateNormalized_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetStateNormalized_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetStateNormalized_Impl() = default;
+ GetStateNormalized_Impl(GetStateNormalized_Impl&& other) = default;
+ GetStateNormalized_Impl& operator=(GetStateNormalized_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 SetStateNormalized_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetStateNormalized_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer);
+ ~SetStateNormalized_Impl() = default;
+ SetStateNormalized_Impl(SetStateNormalized_Impl&& other) = default;
+ SetStateNormalized_Impl& operator=(SetStateNormalized_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 GetStateAbsolute_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetStateAbsolute_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetStateAbsolute_Impl() = default;
+ GetStateAbsolute_Impl(GetStateAbsolute_Impl&& other) = default;
+ GetStateAbsolute_Impl& operator=(GetStateAbsolute_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 SetStateAbsolute_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetStateAbsolute_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer);
+ ~SetStateAbsolute_Impl() = default;
+ SetStateAbsolute_Impl(SetStateAbsolute_Impl&& other) = default;
+ SetStateAbsolute_Impl& operator=(SetStateAbsolute_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 GetMaxAbsoluteBrightness_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetMaxAbsoluteBrightness_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetMaxAbsoluteBrightness_Impl() = default;
+ GetMaxAbsoluteBrightness_Impl(GetMaxAbsoluteBrightness_Impl&& other) = default;
+ GetMaxAbsoluteBrightness_Impl& operator=(GetMaxAbsoluteBrightness_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 GetStateNormalized = GetStateNormalized_Impl<GetStateNormalizedResponse>;
+ using SetStateNormalized = SetStateNormalized_Impl<SetStateNormalizedResponse>;
+ using GetStateAbsolute = GetStateAbsolute_Impl<GetStateAbsoluteResponse>;
+ using SetStateAbsolute = SetStateAbsolute_Impl<SetStateAbsoluteResponse>;
+ using GetMaxAbsoluteBrightness = GetMaxAbsoluteBrightness_Impl<GetMaxAbsoluteBrightnessResponse>;
+ };
+
+ 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_; }
+
+ // Gets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetStateNormalized GetStateNormalized();
+
+ // Gets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetStateNormalized GetStateNormalized(::fidl::BytePart _response_buffer);
+
+ // Sets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetStateNormalized SetStateNormalized(::llcpp::fuchsia::hardware::backlight::State state);
+
+ // Sets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetStateNormalized SetStateNormalized(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer);
+
+ // Gets the current backlight brightness in nits
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetStateAbsolute GetStateAbsolute();
+
+ // Gets the current backlight brightness in nits
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetStateAbsolute GetStateAbsolute(::fidl::BytePart _response_buffer);
+
+ // Sets the current backlight brightness in nits
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetStateAbsolute SetStateAbsolute(::llcpp::fuchsia::hardware::backlight::State state);
+
+ // Sets the current backlight brightness in nits
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetStateAbsolute SetStateAbsolute(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer);
+
+ // Gets the maximum supported backlight brightness in nits, if known.
+ // Otherwise returns error ZX_ERR_NOT_SUPPORTED.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetMaxAbsoluteBrightness GetMaxAbsoluteBrightness();
+
+ // Gets the maximum supported backlight brightness in nits, if known.
+ // Otherwise returns error ZX_ERR_NOT_SUPPORTED.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetMaxAbsoluteBrightness GetMaxAbsoluteBrightness(::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:
+
+ // Gets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetStateNormalized GetStateNormalized(::zx::unowned_channel _client_end);
+
+ // Gets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetStateNormalized GetStateNormalized(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetStateNormalized SetStateNormalized(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state);
+
+ // Sets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetStateNormalized SetStateNormalized(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer);
+
+ // Gets the current backlight brightness in nits
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetStateAbsolute GetStateAbsolute(::zx::unowned_channel _client_end);
+
+ // Gets the current backlight brightness in nits
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetStateAbsolute GetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets the current backlight brightness in nits
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetStateAbsolute SetStateAbsolute(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::backlight::State state);
+
+ // Sets the current backlight brightness in nits
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetStateAbsolute SetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::backlight::State state, ::fidl::BytePart _response_buffer);
+
+ // Gets the maximum supported backlight brightness in nits, if known.
+ // Otherwise returns error ZX_ERR_NOT_SUPPORTED.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetMaxAbsoluteBrightness GetMaxAbsoluteBrightness(::zx::unowned_channel _client_end);
+
+ // Gets the maximum supported backlight brightness in nits, if known.
+ // Otherwise returns error ZX_ERR_NOT_SUPPORTED.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetMaxAbsoluteBrightness GetMaxAbsoluteBrightness(::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:
+
+ // Gets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ static ::fidl::DecodeResult<GetStateNormalizedResponse> GetStateNormalized(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets the current backlight brightness as a percentage value between 0.0
+ // and 1.0
+ static ::fidl::DecodeResult<SetStateNormalizedResponse> SetStateNormalized(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetStateNormalizedRequest> params, ::fidl::BytePart response_buffer);
+
+ // Gets the current backlight brightness in nits
+ static ::fidl::DecodeResult<GetStateAbsoluteResponse> GetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets the current backlight brightness in nits
+ static ::fidl::DecodeResult<SetStateAbsoluteResponse> SetStateAbsolute(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetStateAbsoluteRequest> params, ::fidl::BytePart response_buffer);
+
+ // Gets the maximum supported backlight brightness in nits, if known.
+ // Otherwise returns error ZX_ERR_NOT_SUPPORTED.
+ static ::fidl::DecodeResult<GetMaxAbsoluteBrightnessResponse> GetMaxAbsoluteBrightness(::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 = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetStateNormalizedCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result result);
+ void ReplySuccess(::llcpp::fuchsia::hardware::backlight::State state);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::State state);
+ void Reply(::fidl::DecodedMessage<GetStateNormalizedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetStateNormalizedCompleter = ::fidl::Completer<GetStateNormalizedCompleterBase>;
+
+ virtual void GetStateNormalized(GetStateNormalizedCompleter::Sync _completer) = 0;
+
+ class SetStateNormalizedCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SetStateNormalizedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetStateNormalizedCompleter = ::fidl::Completer<SetStateNormalizedCompleterBase>;
+
+ virtual void SetStateNormalized(::llcpp::fuchsia::hardware::backlight::State state, SetStateNormalizedCompleter::Sync _completer) = 0;
+
+ class GetStateAbsoluteCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result result);
+ void ReplySuccess(::llcpp::fuchsia::hardware::backlight::State state);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::State state);
+ void Reply(::fidl::DecodedMessage<GetStateAbsoluteResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetStateAbsoluteCompleter = ::fidl::Completer<GetStateAbsoluteCompleterBase>;
+
+ virtual void GetStateAbsolute(GetStateAbsoluteCompleter::Sync _completer) = 0;
+
+ class SetStateAbsoluteCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SetStateAbsoluteResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetStateAbsoluteCompleter = ::fidl::Completer<SetStateAbsoluteCompleterBase>;
+
+ virtual void SetStateAbsolute(::llcpp::fuchsia::hardware::backlight::State state, SetStateAbsoluteCompleter::Sync _completer) = 0;
+
+ class GetMaxAbsoluteBrightnessCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result result);
+ void ReplySuccess(double max_brightness);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, double max_brightness);
+ void Reply(::fidl::DecodedMessage<GetMaxAbsoluteBrightnessResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetMaxAbsoluteBrightnessCompleter = ::fidl::Completer<GetMaxAbsoluteBrightnessCompleterBase>;
+
+ virtual void GetMaxAbsoluteBrightness(GetMaxAbsoluteBrightnessCompleter::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 GetStateNormalizedRequest(const ::fidl::DecodedMessage<Device::GetStateNormalizedRequest>& _msg);
+ static void GetStateNormalizedResponse(const ::fidl::DecodedMessage<Device::GetStateNormalizedResponse>& _msg);
+ static void SetStateNormalizedRequest(const ::fidl::DecodedMessage<Device::SetStateNormalizedRequest>& _msg);
+ static void SetStateNormalizedResponse(const ::fidl::DecodedMessage<Device::SetStateNormalizedResponse>& _msg);
+ static void GetStateAbsoluteRequest(const ::fidl::DecodedMessage<Device::GetStateAbsoluteRequest>& _msg);
+ static void GetStateAbsoluteResponse(const ::fidl::DecodedMessage<Device::GetStateAbsoluteResponse>& _msg);
+ static void SetStateAbsoluteRequest(const ::fidl::DecodedMessage<Device::SetStateAbsoluteRequest>& _msg);
+ static void SetStateAbsoluteResponse(const ::fidl::DecodedMessage<Device::SetStateAbsoluteResponse>& _msg);
+ static void GetMaxAbsoluteBrightnessRequest(const ::fidl::DecodedMessage<Device::GetMaxAbsoluteBrightnessRequest>& _msg);
+ static void GetMaxAbsoluteBrightnessResponse(const ::fidl::DecodedMessage<Device::GetMaxAbsoluteBrightnessResponse>& _msg);
+ };
+};
+
+} // namespace backlight
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::State> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::State>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::State, backlight_on) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::State, brightness) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::State) == ::llcpp::fuchsia::hardware::backlight::State::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response, state) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response) == ::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_GetStateNormalized_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response, state) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response) == ::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_GetStateAbsolute_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response) == ::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_SetStateNormalized_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response) == ::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_SetStateAbsolute_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response, max_brightness) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response) == ::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::backlight::Device_GetMaxAbsoluteBrightness_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device::GetStateNormalizedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::backlight::Device::GetStateNormalizedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device::GetStateNormalizedResponse)
+ == ::llcpp::fuchsia::hardware::backlight::Device::GetStateNormalizedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device::GetStateNormalizedResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedRequest)
+ == ::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedRequest, state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedResponse)
+ == ::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device::SetStateNormalizedResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device::GetStateAbsoluteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::backlight::Device::GetStateAbsoluteResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device::GetStateAbsoluteResponse)
+ == ::llcpp::fuchsia::hardware::backlight::Device::GetStateAbsoluteResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device::GetStateAbsoluteResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteRequest)
+ == ::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteRequest, state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteResponse)
+ == ::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device::SetStateAbsoluteResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::backlight::Device::GetMaxAbsoluteBrightnessResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::backlight::Device::GetMaxAbsoluteBrightnessResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::backlight::Device::GetMaxAbsoluteBrightnessResponse)
+ == ::llcpp::fuchsia::hardware::backlight::Device::GetMaxAbsoluteBrightnessResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::backlight::Device::GetMaxAbsoluteBrightnessResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-block-encrypted/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-block-encrypted/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..3c02d16
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-block-encrypted/gen/llcpp/fidl.cc
@@ -0,0 +1,309 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/block/encrypted/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace block {
+namespace encrypted {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDeviceManager_Unseal_Ordinal = 0x7a8062aa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceManager_Unseal_GenOrdinal = 0x170f834d39ed94fblu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_encrypted_DeviceManagerUnsealRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_encrypted_DeviceManagerUnsealResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceManager_Seal_Ordinal = 0x86fda0100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceManager_Seal_GenOrdinal = 0xe63c7aa7840fbf4lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_encrypted_DeviceManagerSealRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_encrypted_DeviceManagerSealResponseTable;
+
+} // namespace
+template <>
+DeviceManager::ResultOf::Unseal_Impl<DeviceManager::UnsealResponse>::Unseal_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> key, uint8_t slot) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnsealRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ UnsealRequest _request = {};
+ _request.key = std::move(key);
+ _request.slot = std::move(slot);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnsealRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DeviceManager::InPlace::Unseal(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DeviceManager::ResultOf::Unseal DeviceManager::SyncClient::Unseal(::fidl::VectorView<uint8_t> key, uint8_t slot) {
+ return ResultOf::Unseal(::zx::unowned_channel(this->channel_), std::move(key), std::move(slot));
+}
+
+DeviceManager::ResultOf::Unseal DeviceManager::Call::Unseal(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> key, uint8_t slot) {
+ return ResultOf::Unseal(std::move(_client_end), std::move(key), std::move(slot));
+}
+
+template <>
+DeviceManager::UnownedResultOf::Unseal_Impl<DeviceManager::UnsealResponse>::Unseal_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> key, uint8_t slot, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UnsealRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UnsealResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UnsealRequest _request = {};
+ _request.key = std::move(key);
+ _request.slot = std::move(slot);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnsealRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DeviceManager::InPlace::Unseal(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DeviceManager::UnownedResultOf::Unseal DeviceManager::SyncClient::Unseal(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> key, uint8_t slot, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unseal(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(key), std::move(slot), std::move(_response_buffer));
+}
+
+DeviceManager::UnownedResultOf::Unseal DeviceManager::Call::Unseal(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> key, uint8_t slot, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unseal(std::move(_client_end), std::move(_request_buffer), std::move(key), std::move(slot), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DeviceManager::UnsealResponse> DeviceManager::InPlace::Unseal(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnsealRequest> params, ::fidl::BytePart response_buffer) {
+ DeviceManager::SetTransactionHeaderFor::UnsealRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceManager::UnsealResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnsealRequest, UnsealResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceManager::UnsealResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DeviceManager::ResultOf::Seal_Impl<DeviceManager::SealResponse>::Seal_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SealRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SealRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SealRequest));
+ ::fidl::DecodedMessage<SealRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DeviceManager::InPlace::Seal(std::move(_client_end), Super::response_buffer()));
+}
+
+DeviceManager::ResultOf::Seal DeviceManager::SyncClient::Seal() {
+ return ResultOf::Seal(::zx::unowned_channel(this->channel_));
+}
+
+DeviceManager::ResultOf::Seal DeviceManager::Call::Seal(::zx::unowned_channel _client_end) {
+ return ResultOf::Seal(std::move(_client_end));
+}
+
+template <>
+DeviceManager::UnownedResultOf::Seal_Impl<DeviceManager::SealResponse>::Seal_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SealRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SealRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SealRequest));
+ ::fidl::DecodedMessage<SealRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DeviceManager::InPlace::Seal(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DeviceManager::UnownedResultOf::Seal DeviceManager::SyncClient::Seal(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Seal(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DeviceManager::UnownedResultOf::Seal DeviceManager::Call::Seal(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Seal(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DeviceManager::SealResponse> DeviceManager::InPlace::Seal(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SealRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SealRequest> params(std::move(_request_buffer));
+ DeviceManager::SetTransactionHeaderFor::SealRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceManager::SealResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SealRequest, SealResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DeviceManager::SealResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DeviceManager::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDeviceManager_Unseal_Ordinal:
+ case kDeviceManager_Unseal_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnsealRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Unseal(std::move(message->key), std::move(message->slot),
+ Interface::UnsealCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceManager_Seal_Ordinal:
+ case kDeviceManager_Seal_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SealRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Seal(
+ Interface::SealCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DeviceManager::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DeviceManager::Interface::UnsealCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnsealResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<UnsealResponse*>(_write_bytes);
+ DeviceManager::SetTransactionHeaderFor::UnsealResponse(
+ ::fidl::DecodedMessage<UnsealResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnsealResponse::PrimarySize,
+ UnsealResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnsealResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnsealResponse>(std::move(_response_bytes)));
+}
+
+void DeviceManager::Interface::UnsealCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < UnsealResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<UnsealResponse*>(_buffer.data());
+ DeviceManager::SetTransactionHeaderFor::UnsealResponse(
+ ::fidl::DecodedMessage<UnsealResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnsealResponse::PrimarySize,
+ UnsealResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(UnsealResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnsealResponse>(std::move(_buffer)));
+}
+
+void DeviceManager::Interface::UnsealCompleterBase::Reply(::fidl::DecodedMessage<UnsealResponse> params) {
+ DeviceManager::SetTransactionHeaderFor::UnsealResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DeviceManager::Interface::SealCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SealResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SealResponse*>(_write_bytes);
+ DeviceManager::SetTransactionHeaderFor::SealResponse(
+ ::fidl::DecodedMessage<SealResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SealResponse::PrimarySize,
+ SealResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SealResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SealResponse>(std::move(_response_bytes)));
+}
+
+void DeviceManager::Interface::SealCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SealResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SealResponse*>(_buffer.data());
+ DeviceManager::SetTransactionHeaderFor::SealResponse(
+ ::fidl::DecodedMessage<SealResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SealResponse::PrimarySize,
+ SealResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SealResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SealResponse>(std::move(_buffer)));
+}
+
+void DeviceManager::Interface::SealCompleterBase::Reply(::fidl::DecodedMessage<SealResponse> params) {
+ DeviceManager::SetTransactionHeaderFor::SealResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DeviceManager::SetTransactionHeaderFor::UnsealRequest(const ::fidl::DecodedMessage<DeviceManager::UnsealRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceManager_Unseal_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DeviceManager::SetTransactionHeaderFor::UnsealResponse(const ::fidl::DecodedMessage<DeviceManager::UnsealResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceManager_Unseal_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceManager::SetTransactionHeaderFor::SealRequest(const ::fidl::DecodedMessage<DeviceManager::SealRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceManager_Seal_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DeviceManager::SetTransactionHeaderFor::SealResponse(const ::fidl::DecodedMessage<DeviceManager::SealResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceManager_Seal_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace encrypted
+} // namespace block
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-block-encrypted/gen/llcpp/include/fuchsia/hardware/block/encrypted/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-block-encrypted/gen/llcpp/include/fuchsia/hardware/block/encrypted/llcpp/fidl.h
new file mode 100644
index 0000000..c1a72c1
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-block-encrypted/gen/llcpp/include/fuchsia/hardware/block/encrypted/llcpp/fidl.h
@@ -0,0 +1,416 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace block {
+namespace encrypted {
+
+class DeviceManager;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_encrypted_DeviceManagerUnsealRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_encrypted_DeviceManagerUnsealResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_encrypted_DeviceManagerSealRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_encrypted_DeviceManagerSealResponseTable;
+
+// An interface to the zxcrypt driver, as bound to a single block device with
+// a zxcrypt superblock. zxcrypt devices are encrypted, and before their
+// plaintext contents can be accessed, they must be unsealed with a key.
+// This protocol allows the caller to make requests to unseal the device (by
+// providing the appropriate key) and to seal the device (rendering its
+// contents inaccessible).
+class DeviceManager final {
+ DeviceManager() = delete;
+ public:
+
+ struct UnsealResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_encrypted_DeviceManagerUnsealResponseTable;
+ 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 UnsealRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> key;
+ uint8_t slot;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_encrypted_DeviceManagerUnsealRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 256;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 256;
+ 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 = UnsealResponse;
+ };
+
+ struct SealResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_encrypted_DeviceManagerSealResponseTable;
+ 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 SealRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Unseal_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Unseal_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> key, uint8_t slot);
+ ~Unseal_Impl() = default;
+ Unseal_Impl(Unseal_Impl&& other) = default;
+ Unseal_Impl& operator=(Unseal_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 Seal_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Seal_Impl(::zx::unowned_channel _client_end);
+ ~Seal_Impl() = default;
+ Seal_Impl(Seal_Impl&& other) = default;
+ Seal_Impl& operator=(Seal_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 Unseal = Unseal_Impl<UnsealResponse>;
+ using Seal = Seal_Impl<SealResponse>;
+ };
+
+ // 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 Unseal_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Unseal_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> key, uint8_t slot, ::fidl::BytePart _response_buffer);
+ ~Unseal_Impl() = default;
+ Unseal_Impl(Unseal_Impl&& other) = default;
+ Unseal_Impl& operator=(Unseal_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 Seal_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Seal_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Seal_Impl() = default;
+ Seal_Impl(Seal_Impl&& other) = default;
+ Seal_Impl& operator=(Seal_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 Unseal = Unseal_Impl<UnsealResponse>;
+ using Seal = Seal_Impl<SealResponse>;
+ };
+
+ 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_; }
+
+ // Attempts to unseal the device by using the provided master key to unwrap
+ // the data key wrapped in the specified key slot. If the key provided was
+ // the correct key for this slot, then the device node responding to this
+ // protocol will create an unsealed zxcrypt device as a child of itself in
+ // the device tree before returning success.
+ // Returns `ZX_ERR_INVALID_ARGS` if `slot` is invalid.
+ // Returns `ZX_ERR_BAD_STATE` and keeps the device open if the device is already unsealed.
+ // Returns other errors if operations on the underlying block device return errors.
+ // Returns `ZX_OK` on success.
+ // Allocates 320 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Unseal Unseal(::fidl::VectorView<uint8_t> key, uint8_t slot);
+
+ // Attempts to unseal the device by using the provided master key to unwrap
+ // the data key wrapped in the specified key slot. If the key provided was
+ // the correct key for this slot, then the device node responding to this
+ // protocol will create an unsealed zxcrypt device as a child of itself in
+ // the device tree before returning success.
+ // Returns `ZX_ERR_INVALID_ARGS` if `slot` is invalid.
+ // Returns `ZX_ERR_BAD_STATE` and keeps the device open if the device is already unsealed.
+ // Returns other errors if operations on the underlying block device return errors.
+ // Returns `ZX_OK` on success.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Unseal Unseal(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> key, uint8_t slot, ::fidl::BytePart _response_buffer);
+
+ // Seals the device, causing any previously-created child zxcrypt Device to
+ // be removed some time later. (Someday we'd like this to only return once
+ // the unsealed child device is removed, but that's not straightforward today.)
+ // Returns `ZX_ERR_BAD_STATE` if the device is already sealed.
+ // Returns `ZX_OK` on success.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Seal Seal();
+
+ // Seals the device, causing any previously-created child zxcrypt Device to
+ // be removed some time later. (Someday we'd like this to only return once
+ // the unsealed child device is removed, but that's not straightforward today.)
+ // Returns `ZX_ERR_BAD_STATE` if the device is already sealed.
+ // Returns `ZX_OK` on success.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Seal Seal(::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:
+
+ // Attempts to unseal the device by using the provided master key to unwrap
+ // the data key wrapped in the specified key slot. If the key provided was
+ // the correct key for this slot, then the device node responding to this
+ // protocol will create an unsealed zxcrypt device as a child of itself in
+ // the device tree before returning success.
+ // Returns `ZX_ERR_INVALID_ARGS` if `slot` is invalid.
+ // Returns `ZX_ERR_BAD_STATE` and keeps the device open if the device is already unsealed.
+ // Returns other errors if operations on the underlying block device return errors.
+ // Returns `ZX_OK` on success.
+ // Allocates 320 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Unseal Unseal(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> key, uint8_t slot);
+
+ // Attempts to unseal the device by using the provided master key to unwrap
+ // the data key wrapped in the specified key slot. If the key provided was
+ // the correct key for this slot, then the device node responding to this
+ // protocol will create an unsealed zxcrypt device as a child of itself in
+ // the device tree before returning success.
+ // Returns `ZX_ERR_INVALID_ARGS` if `slot` is invalid.
+ // Returns `ZX_ERR_BAD_STATE` and keeps the device open if the device is already unsealed.
+ // Returns other errors if operations on the underlying block device return errors.
+ // Returns `ZX_OK` on success.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Unseal Unseal(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> key, uint8_t slot, ::fidl::BytePart _response_buffer);
+
+ // Seals the device, causing any previously-created child zxcrypt Device to
+ // be removed some time later. (Someday we'd like this to only return once
+ // the unsealed child device is removed, but that's not straightforward today.)
+ // Returns `ZX_ERR_BAD_STATE` if the device is already sealed.
+ // Returns `ZX_OK` on success.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Seal Seal(::zx::unowned_channel _client_end);
+
+ // Seals the device, causing any previously-created child zxcrypt Device to
+ // be removed some time later. (Someday we'd like this to only return once
+ // the unsealed child device is removed, but that's not straightforward today.)
+ // Returns `ZX_ERR_BAD_STATE` if the device is already sealed.
+ // Returns `ZX_OK` on success.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Seal Seal(::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:
+
+ // Attempts to unseal the device by using the provided master key to unwrap
+ // the data key wrapped in the specified key slot. If the key provided was
+ // the correct key for this slot, then the device node responding to this
+ // protocol will create an unsealed zxcrypt device as a child of itself in
+ // the device tree before returning success.
+ // Returns `ZX_ERR_INVALID_ARGS` if `slot` is invalid.
+ // Returns `ZX_ERR_BAD_STATE` and keeps the device open if the device is already unsealed.
+ // Returns other errors if operations on the underlying block device return errors.
+ // Returns `ZX_OK` on success.
+ static ::fidl::DecodeResult<UnsealResponse> Unseal(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnsealRequest> params, ::fidl::BytePart response_buffer);
+
+ // Seals the device, causing any previously-created child zxcrypt Device to
+ // be removed some time later. (Someday we'd like this to only return once
+ // the unsealed child device is removed, but that's not straightforward today.)
+ // Returns `ZX_ERR_BAD_STATE` if the device is already sealed.
+ // Returns `ZX_OK` on success.
+ static ::fidl::DecodeResult<SealResponse> Seal(::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 = DeviceManager;
+ using _Base = ::fidl::CompleterBase;
+
+ class UnsealCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<UnsealResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnsealCompleter = ::fidl::Completer<UnsealCompleterBase>;
+
+ virtual void Unseal(::fidl::VectorView<uint8_t> key, uint8_t slot, UnsealCompleter::Sync _completer) = 0;
+
+ class SealCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SealResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SealCompleter = ::fidl::Completer<SealCompleterBase>;
+
+ virtual void Seal(SealCompleter::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 UnsealRequest(const ::fidl::DecodedMessage<DeviceManager::UnsealRequest>& _msg);
+ static void UnsealResponse(const ::fidl::DecodedMessage<DeviceManager::UnsealResponse>& _msg);
+ static void SealRequest(const ::fidl::DecodedMessage<DeviceManager::SealRequest>& _msg);
+ static void SealResponse(const ::fidl::DecodedMessage<DeviceManager::SealResponse>& _msg);
+ };
+};
+
+// We require simple layout to use the simple C bindings, and simple layout
+// requires that we have non-maximal length bounds, so give some excessively
+// large key length here so we can use the simple layout.
+constexpr uint32_t MAX_KEY_SIZE = 256u;
+
+} // namespace encrypted
+} // namespace block
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealRequest)
+ == ::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealRequest, key) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealRequest, slot) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealResponse)
+ == ::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::UnsealResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::SealResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::SealResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::SealResponse)
+ == ::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::SealResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::encrypted::DeviceManager::SealResponse, status) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-block-partition/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-block-partition/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..e59968d
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-block-partition/gen/llcpp/fidl.cc
@@ -0,0 +1,1241 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/block/partition/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace block {
+namespace partition {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetInfo_Ordinal = 0x7279049800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetInfo_GenOrdinal = 0x79df1a5cdb6cc6a3lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetStats_Ordinal = 0x73b9275400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetStats_GenOrdinal = 0x53d9542a778385aelu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetStatsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetFifo_Ordinal = 0x63616dbe00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetFifo_GenOrdinal = 0x507ea563fb50747elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetFifoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPartition_AttachVmo_Ordinal = 0x72df2e6600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_AttachVmo_GenOrdinal = 0x7e726e5993add9b7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionAttachVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionAttachVmoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPartition_CloseFifo_Ordinal = 0x6b4a461300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_CloseFifo_GenOrdinal = 0x4dc09acdfa2a2a65lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionCloseFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionCloseFifoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPartition_RebindDevice_Ordinal = 0x2c1ffdb000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_RebindDevice_GenOrdinal = 0x5d728cbd5312c9aelu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionRebindDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionRebindDeviceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetTypeGuid_Ordinal = 0x40d3186c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetTypeGuid_GenOrdinal = 0x111843d737a9b847lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetTypeGuidRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetTypeGuidResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetInstanceGuid_Ordinal = 0x69f426600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetInstanceGuid_GenOrdinal = 0x14a5a573b275d435lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInstanceGuidRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInstanceGuidResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetName_Ordinal = 0x39b49c4000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPartition_GetName_GenOrdinal = 0x7e3c6f0b0937fc02lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetNameResponseTable;
+
+} // namespace
+template <>
+Partition::ResultOf::GetInfo_Impl<Partition::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Partition::ResultOf::GetInfo Partition::SyncClient::GetInfo() {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
+}
+
+Partition::ResultOf::GetInfo Partition::Call::GetInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInfo(std::move(_client_end));
+}
+
+template <>
+Partition::UnownedResultOf::GetInfo_Impl<Partition::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::GetInfo Partition::SyncClient::GetInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::GetInfo Partition::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::GetInfoResponse> Partition::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInfoRequest> params(std::move(_request_buffer));
+ Partition::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Partition::ResultOf::GetStats_Impl<Partition::GetStatsResponse>::GetStats_Impl(::zx::unowned_channel _client_end, bool clear) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStatsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStatsRequest*>(_write_bytes);
+ _request.clear = std::move(clear);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStatsRequest));
+ ::fidl::DecodedMessage<GetStatsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Partition::ResultOf::GetStats Partition::SyncClient::GetStats(bool clear) {
+ return ResultOf::GetStats(::zx::unowned_channel(this->channel_), std::move(clear));
+}
+
+Partition::ResultOf::GetStats Partition::Call::GetStats(::zx::unowned_channel _client_end, bool clear) {
+ return ResultOf::GetStats(std::move(_client_end), std::move(clear));
+}
+
+template <>
+Partition::UnownedResultOf::GetStats_Impl<Partition::GetStatsResponse>::GetStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetStatsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetStatsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetStatsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStatsRequest*>(_request_buffer.data());
+ _request.clear = std::move(clear);
+ _request_buffer.set_actual(sizeof(GetStatsRequest));
+ ::fidl::DecodedMessage<GetStatsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::GetStats Partition::SyncClient::GetStats(::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStats(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(clear), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::GetStats Partition::Call::GetStats(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStats(std::move(_client_end), std::move(_request_buffer), std::move(clear), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::GetStatsResponse> Partition::InPlace::GetStats(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStatsRequest> params, ::fidl::BytePart response_buffer) {
+ Partition::SetTransactionHeaderFor::GetStatsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetStatsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStatsRequest, GetStatsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetStatsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Partition::ResultOf::GetFifo_Impl<Partition::GetFifoResponse>::GetFifo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFifoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFifoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFifoRequest));
+ ::fidl::DecodedMessage<GetFifoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::GetFifo(std::move(_client_end), Super::response_buffer()));
+}
+
+Partition::ResultOf::GetFifo Partition::SyncClient::GetFifo() {
+ return ResultOf::GetFifo(::zx::unowned_channel(this->channel_));
+}
+
+Partition::ResultOf::GetFifo Partition::Call::GetFifo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFifo(std::move(_client_end));
+}
+
+template <>
+Partition::UnownedResultOf::GetFifo_Impl<Partition::GetFifoResponse>::GetFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFifoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFifoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFifoRequest));
+ ::fidl::DecodedMessage<GetFifoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::GetFifo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::GetFifo Partition::SyncClient::GetFifo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFifo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::GetFifo Partition::Call::GetFifo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFifo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::GetFifoResponse> Partition::InPlace::GetFifo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFifoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFifoRequest> params(std::move(_request_buffer));
+ Partition::SetTransactionHeaderFor::GetFifoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetFifoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFifoRequest, GetFifoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetFifoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Partition::ResultOf::AttachVmo_Impl<Partition::AttachVmoResponse>::AttachVmo_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AttachVmoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AttachVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AttachVmoRequest*>(_write_bytes);
+ _request.vmo = std::move(vmo);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AttachVmoRequest));
+ ::fidl::DecodedMessage<AttachVmoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Partition::ResultOf::AttachVmo Partition::SyncClient::AttachVmo(::zx::vmo vmo) {
+ return ResultOf::AttachVmo(::zx::unowned_channel(this->channel_), std::move(vmo));
+}
+
+Partition::ResultOf::AttachVmo Partition::Call::AttachVmo(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ return ResultOf::AttachVmo(std::move(_client_end), std::move(vmo));
+}
+
+template <>
+Partition::UnownedResultOf::AttachVmo_Impl<Partition::AttachVmoResponse>::AttachVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AttachVmoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AttachVmoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AttachVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AttachVmoRequest*>(_request_buffer.data());
+ _request.vmo = std::move(vmo);
+ _request_buffer.set_actual(sizeof(AttachVmoRequest));
+ ::fidl::DecodedMessage<AttachVmoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::AttachVmo Partition::SyncClient::AttachVmo(::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AttachVmo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::AttachVmo Partition::Call::AttachVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AttachVmo(std::move(_client_end), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::AttachVmoResponse> Partition::InPlace::AttachVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AttachVmoRequest> params, ::fidl::BytePart response_buffer) {
+ Partition::SetTransactionHeaderFor::AttachVmoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::AttachVmoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AttachVmoRequest, AttachVmoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::AttachVmoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Partition::ResultOf::CloseFifo_Impl<Partition::CloseFifoResponse>::CloseFifo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseFifoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseFifoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseFifoRequest));
+ ::fidl::DecodedMessage<CloseFifoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::CloseFifo(std::move(_client_end), Super::response_buffer()));
+}
+
+Partition::ResultOf::CloseFifo Partition::SyncClient::CloseFifo() {
+ return ResultOf::CloseFifo(::zx::unowned_channel(this->channel_));
+}
+
+Partition::ResultOf::CloseFifo Partition::Call::CloseFifo(::zx::unowned_channel _client_end) {
+ return ResultOf::CloseFifo(std::move(_client_end));
+}
+
+template <>
+Partition::UnownedResultOf::CloseFifo_Impl<Partition::CloseFifoResponse>::CloseFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseFifoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseFifoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseFifoRequest));
+ ::fidl::DecodedMessage<CloseFifoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::CloseFifo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::CloseFifo Partition::SyncClient::CloseFifo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CloseFifo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::CloseFifo Partition::Call::CloseFifo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CloseFifo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::CloseFifoResponse> Partition::InPlace::CloseFifo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseFifoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseFifoRequest> params(std::move(_request_buffer));
+ Partition::SetTransactionHeaderFor::CloseFifoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::CloseFifoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseFifoRequest, CloseFifoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::CloseFifoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Partition::ResultOf::RebindDevice_Impl<Partition::RebindDeviceResponse>::RebindDevice_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RebindDeviceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RebindDeviceRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RebindDeviceRequest));
+ ::fidl::DecodedMessage<RebindDeviceRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::RebindDevice(std::move(_client_end), Super::response_buffer()));
+}
+
+Partition::ResultOf::RebindDevice Partition::SyncClient::RebindDevice() {
+ return ResultOf::RebindDevice(::zx::unowned_channel(this->channel_));
+}
+
+Partition::ResultOf::RebindDevice Partition::Call::RebindDevice(::zx::unowned_channel _client_end) {
+ return ResultOf::RebindDevice(std::move(_client_end));
+}
+
+template <>
+Partition::UnownedResultOf::RebindDevice_Impl<Partition::RebindDeviceResponse>::RebindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RebindDeviceRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, RebindDeviceRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(RebindDeviceRequest));
+ ::fidl::DecodedMessage<RebindDeviceRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::RebindDevice(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::RebindDevice Partition::SyncClient::RebindDevice(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RebindDevice(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::RebindDevice Partition::Call::RebindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RebindDevice(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::RebindDeviceResponse> Partition::InPlace::RebindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(RebindDeviceRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<RebindDeviceRequest> params(std::move(_request_buffer));
+ Partition::SetTransactionHeaderFor::RebindDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::RebindDeviceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RebindDeviceRequest, RebindDeviceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::RebindDeviceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Partition::ResultOf::GetTypeGuid_Impl<Partition::GetTypeGuidResponse>::GetTypeGuid_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTypeGuidRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTypeGuidRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTypeGuidRequest));
+ ::fidl::DecodedMessage<GetTypeGuidRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::GetTypeGuid(std::move(_client_end), Super::response_buffer()));
+}
+
+Partition::ResultOf::GetTypeGuid Partition::SyncClient::GetTypeGuid() {
+ return ResultOf::GetTypeGuid(::zx::unowned_channel(this->channel_));
+}
+
+Partition::ResultOf::GetTypeGuid Partition::Call::GetTypeGuid(::zx::unowned_channel _client_end) {
+ return ResultOf::GetTypeGuid(std::move(_client_end));
+}
+
+template <>
+Partition::UnownedResultOf::GetTypeGuid_Impl<Partition::GetTypeGuidResponse>::GetTypeGuid_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTypeGuidRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTypeGuidRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTypeGuidRequest));
+ ::fidl::DecodedMessage<GetTypeGuidRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::GetTypeGuid(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::GetTypeGuid Partition::SyncClient::GetTypeGuid(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTypeGuid(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::GetTypeGuid Partition::Call::GetTypeGuid(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTypeGuid(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::GetTypeGuidResponse> Partition::InPlace::GetTypeGuid(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTypeGuidRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTypeGuidRequest> params(std::move(_request_buffer));
+ Partition::SetTransactionHeaderFor::GetTypeGuidRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetTypeGuidResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTypeGuidRequest, GetTypeGuidResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetTypeGuidResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Partition::ResultOf::GetInstanceGuid_Impl<Partition::GetInstanceGuidResponse>::GetInstanceGuid_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInstanceGuidRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInstanceGuidRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInstanceGuidRequest));
+ ::fidl::DecodedMessage<GetInstanceGuidRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::GetInstanceGuid(std::move(_client_end), Super::response_buffer()));
+}
+
+Partition::ResultOf::GetInstanceGuid Partition::SyncClient::GetInstanceGuid() {
+ return ResultOf::GetInstanceGuid(::zx::unowned_channel(this->channel_));
+}
+
+Partition::ResultOf::GetInstanceGuid Partition::Call::GetInstanceGuid(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInstanceGuid(std::move(_client_end));
+}
+
+template <>
+Partition::UnownedResultOf::GetInstanceGuid_Impl<Partition::GetInstanceGuidResponse>::GetInstanceGuid_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInstanceGuidRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInstanceGuidRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInstanceGuidRequest));
+ ::fidl::DecodedMessage<GetInstanceGuidRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::GetInstanceGuid(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::GetInstanceGuid Partition::SyncClient::GetInstanceGuid(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInstanceGuid(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::GetInstanceGuid Partition::Call::GetInstanceGuid(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInstanceGuid(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::GetInstanceGuidResponse> Partition::InPlace::GetInstanceGuid(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInstanceGuidRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInstanceGuidRequest> params(std::move(_request_buffer));
+ Partition::SetTransactionHeaderFor::GetInstanceGuidRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetInstanceGuidResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInstanceGuidRequest, GetInstanceGuidResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetInstanceGuidResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Partition::ResultOf::GetName_Impl<Partition::GetNameResponse>::GetName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNameRequest));
+ ::fidl::DecodedMessage<GetNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Partition::InPlace::GetName(std::move(_client_end), Super::response_buffer()));
+}
+
+Partition::ResultOf::GetName Partition::SyncClient::GetName() {
+ return ResultOf::GetName(::zx::unowned_channel(this->channel_));
+}
+
+Partition::ResultOf::GetName Partition::Call::GetName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetName(std::move(_client_end));
+}
+
+template <>
+Partition::UnownedResultOf::GetName_Impl<Partition::GetNameResponse>::GetName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetNameRequest));
+ ::fidl::DecodedMessage<GetNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Partition::InPlace::GetName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Partition::UnownedResultOf::GetName Partition::SyncClient::GetName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Partition::UnownedResultOf::GetName Partition::Call::GetName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Partition::GetNameResponse> Partition::InPlace::GetName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetNameRequest> params(std::move(_request_buffer));
+ Partition::SetTransactionHeaderFor::GetNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNameRequest, GetNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Partition::GetNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Partition::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kPartition_GetInfo_Ordinal:
+ case kPartition_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInfo(
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kPartition_GetStats_Ordinal:
+ case kPartition_GetStats_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStatsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetStats(std::move(message->clear),
+ Interface::GetStatsCompleter::Sync(txn));
+ return true;
+ }
+ case kPartition_GetFifo_Ordinal:
+ case kPartition_GetFifo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFifoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFifo(
+ Interface::GetFifoCompleter::Sync(txn));
+ return true;
+ }
+ case kPartition_AttachVmo_Ordinal:
+ case kPartition_AttachVmo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AttachVmoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AttachVmo(std::move(message->vmo),
+ Interface::AttachVmoCompleter::Sync(txn));
+ return true;
+ }
+ case kPartition_CloseFifo_Ordinal:
+ case kPartition_CloseFifo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseFifoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->CloseFifo(
+ Interface::CloseFifoCompleter::Sync(txn));
+ return true;
+ }
+ case kPartition_RebindDevice_Ordinal:
+ case kPartition_RebindDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RebindDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->RebindDevice(
+ Interface::RebindDeviceCompleter::Sync(txn));
+ return true;
+ }
+ case kPartition_GetTypeGuid_Ordinal:
+ case kPartition_GetTypeGuid_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTypeGuidRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetTypeGuid(
+ Interface::GetTypeGuidCompleter::Sync(txn));
+ return true;
+ }
+ case kPartition_GetInstanceGuid_Ordinal:
+ case kPartition_GetInstanceGuid_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInstanceGuidRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInstanceGuid(
+ Interface::GetInstanceGuidCompleter::Sync(txn));
+ return true;
+ }
+ case kPartition_GetName_Ordinal:
+ case kPartition_GetName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetName(
+ Interface::GetNameCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Partition::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Partition::Interface::GetInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInfoResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInfoResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ Partition::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Partition::Interface::GetStatsCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetStatsResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetStatsResponse(
+ ::fidl::DecodedMessage<GetStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatsResponse::PrimarySize,
+ GetStatsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetStatsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats) {
+ if (_buffer.capacity() < GetStatsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetStatsResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetStatsResponse(
+ ::fidl::DecodedMessage<GetStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatsResponse::PrimarySize,
+ GetStatsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetStatsCompleterBase::Reply(::fidl::DecodedMessage<GetStatsResponse> params) {
+ Partition::SetTransactionHeaderFor::GetStatsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Partition::Interface::GetFifoCompleterBase::Reply(int32_t status, ::zx::fifo fifo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFifoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetFifoResponse*>(_write_bytes);
+ Partition::SetTransactionHeaderFor::GetFifoResponse(
+ ::fidl::DecodedMessage<GetFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFifoResponse::PrimarySize,
+ GetFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.fifo = std::move(fifo);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFifoResponse>(std::move(_response_bytes)));
+}
+
+void Partition::Interface::GetFifoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::fifo fifo) {
+ if (_buffer.capacity() < GetFifoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetFifoResponse*>(_buffer.data());
+ Partition::SetTransactionHeaderFor::GetFifoResponse(
+ ::fidl::DecodedMessage<GetFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFifoResponse::PrimarySize,
+ GetFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.fifo = std::move(fifo);
+ _buffer.set_actual(sizeof(GetFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFifoResponse>(std::move(_buffer)));
+}
+
+void Partition::Interface::GetFifoCompleterBase::Reply(::fidl::DecodedMessage<GetFifoResponse> params) {
+ Partition::SetTransactionHeaderFor::GetFifoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Partition::Interface::AttachVmoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AttachVmoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AttachVmoResponse _response = {};
+ Partition::SetTransactionHeaderFor::AttachVmoResponse(
+ ::fidl::DecodedMessage<AttachVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AttachVmoResponse::PrimarySize,
+ AttachVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.vmoid = std::move(vmoid);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::AttachVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid) {
+ if (_buffer.capacity() < AttachVmoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AttachVmoResponse _response = {};
+ Partition::SetTransactionHeaderFor::AttachVmoResponse(
+ ::fidl::DecodedMessage<AttachVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AttachVmoResponse::PrimarySize,
+ AttachVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.vmoid = std::move(vmoid);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::AttachVmoCompleterBase::Reply(::fidl::DecodedMessage<AttachVmoResponse> params) {
+ Partition::SetTransactionHeaderFor::AttachVmoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Partition::Interface::CloseFifoCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseFifoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseFifoResponse*>(_write_bytes);
+ Partition::SetTransactionHeaderFor::CloseFifoResponse(
+ ::fidl::DecodedMessage<CloseFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseFifoResponse::PrimarySize,
+ CloseFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseFifoResponse>(std::move(_response_bytes)));
+}
+
+void Partition::Interface::CloseFifoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < CloseFifoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseFifoResponse*>(_buffer.data());
+ Partition::SetTransactionHeaderFor::CloseFifoResponse(
+ ::fidl::DecodedMessage<CloseFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseFifoResponse::PrimarySize,
+ CloseFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CloseFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseFifoResponse>(std::move(_buffer)));
+}
+
+void Partition::Interface::CloseFifoCompleterBase::Reply(::fidl::DecodedMessage<CloseFifoResponse> params) {
+ Partition::SetTransactionHeaderFor::CloseFifoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Partition::Interface::RebindDeviceCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RebindDeviceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RebindDeviceResponse*>(_write_bytes);
+ Partition::SetTransactionHeaderFor::RebindDeviceResponse(
+ ::fidl::DecodedMessage<RebindDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RebindDeviceResponse::PrimarySize,
+ RebindDeviceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RebindDeviceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RebindDeviceResponse>(std::move(_response_bytes)));
+}
+
+void Partition::Interface::RebindDeviceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < RebindDeviceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RebindDeviceResponse*>(_buffer.data());
+ Partition::SetTransactionHeaderFor::RebindDeviceResponse(
+ ::fidl::DecodedMessage<RebindDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RebindDeviceResponse::PrimarySize,
+ RebindDeviceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(RebindDeviceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RebindDeviceResponse>(std::move(_buffer)));
+}
+
+void Partition::Interface::RebindDeviceCompleterBase::Reply(::fidl::DecodedMessage<RebindDeviceResponse> params) {
+ Partition::SetTransactionHeaderFor::RebindDeviceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Partition::Interface::GetTypeGuidCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTypeGuidResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetTypeGuidResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetTypeGuidResponse(
+ ::fidl::DecodedMessage<GetTypeGuidResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTypeGuidResponse::PrimarySize,
+ GetTypeGuidResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.guid = std::move(guid);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetTypeGuidCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
+ if (_buffer.capacity() < GetTypeGuidResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTypeGuidResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetTypeGuidResponse(
+ ::fidl::DecodedMessage<GetTypeGuidResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTypeGuidResponse::PrimarySize,
+ GetTypeGuidResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.guid = std::move(guid);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetTypeGuidCompleterBase::Reply(::fidl::DecodedMessage<GetTypeGuidResponse> params) {
+ Partition::SetTransactionHeaderFor::GetTypeGuidResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Partition::Interface::GetInstanceGuidCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInstanceGuidResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInstanceGuidResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetInstanceGuidResponse(
+ ::fidl::DecodedMessage<GetInstanceGuidResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInstanceGuidResponse::PrimarySize,
+ GetInstanceGuidResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.guid = std::move(guid);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetInstanceGuidCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
+ if (_buffer.capacity() < GetInstanceGuidResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInstanceGuidResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetInstanceGuidResponse(
+ ::fidl::DecodedMessage<GetInstanceGuidResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInstanceGuidResponse::PrimarySize,
+ GetInstanceGuidResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.guid = std::move(guid);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetInstanceGuidCompleterBase::Reply(::fidl::DecodedMessage<GetInstanceGuidResponse> params) {
+ Partition::SetTransactionHeaderFor::GetInstanceGuidResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Partition::Interface::GetNameCompleterBase::Reply(int32_t status, ::fidl::StringView name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetNameResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetNameResponse(
+ ::fidl::DecodedMessage<GetNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNameResponse::PrimarySize,
+ GetNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetNameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::StringView name) {
+ if (_buffer.capacity() < GetNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetNameResponse _response = {};
+ Partition::SetTransactionHeaderFor::GetNameResponse(
+ ::fidl::DecodedMessage<GetNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNameResponse::PrimarySize,
+ GetNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Partition::Interface::GetNameCompleterBase::Reply(::fidl::DecodedMessage<GetNameResponse> params) {
+ Partition::SetTransactionHeaderFor::GetNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Partition::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<Partition::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<Partition::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Partition::SetTransactionHeaderFor::GetStatsRequest(const ::fidl::DecodedMessage<Partition::GetStatsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::GetStatsResponse(const ::fidl::DecodedMessage<Partition::GetStatsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Partition::SetTransactionHeaderFor::GetFifoRequest(const ::fidl::DecodedMessage<Partition::GetFifoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::GetFifoResponse(const ::fidl::DecodedMessage<Partition::GetFifoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Partition::SetTransactionHeaderFor::AttachVmoRequest(const ::fidl::DecodedMessage<Partition::AttachVmoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_AttachVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::AttachVmoResponse(const ::fidl::DecodedMessage<Partition::AttachVmoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_AttachVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Partition::SetTransactionHeaderFor::CloseFifoRequest(const ::fidl::DecodedMessage<Partition::CloseFifoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_CloseFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::CloseFifoResponse(const ::fidl::DecodedMessage<Partition::CloseFifoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_CloseFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Partition::SetTransactionHeaderFor::RebindDeviceRequest(const ::fidl::DecodedMessage<Partition::RebindDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_RebindDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::RebindDeviceResponse(const ::fidl::DecodedMessage<Partition::RebindDeviceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_RebindDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Partition::SetTransactionHeaderFor::GetTypeGuidRequest(const ::fidl::DecodedMessage<Partition::GetTypeGuidRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetTypeGuid_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::GetTypeGuidResponse(const ::fidl::DecodedMessage<Partition::GetTypeGuidResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetTypeGuid_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Partition::SetTransactionHeaderFor::GetInstanceGuidRequest(const ::fidl::DecodedMessage<Partition::GetInstanceGuidRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetInstanceGuid_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::GetInstanceGuidResponse(const ::fidl::DecodedMessage<Partition::GetInstanceGuidResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetInstanceGuid_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Partition::SetTransactionHeaderFor::GetNameRequest(const ::fidl::DecodedMessage<Partition::GetNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Partition::SetTransactionHeaderFor::GetNameResponse(const ::fidl::DecodedMessage<Partition::GetNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPartition_GetName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace partition
+} // namespace block
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-block-partition/gen/llcpp/include/fuchsia/hardware/block/partition/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-block-partition/gen/llcpp/include/fuchsia/hardware/block/partition/llcpp/fidl.h
new file mode 100644
index 0000000..5e61559
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-block-partition/gen/llcpp/include/fuchsia/hardware/block/partition/llcpp/fidl.h
@@ -0,0 +1,1037 @@
+// 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>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace block {
+namespace partition {
+
+class Partition;
+struct GUID;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetStatsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetFifoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionAttachVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionAttachVmoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionCloseFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionCloseFifoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionRebindDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionRebindDeviceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetTypeGuidRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetTypeGuidResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInstanceGuidRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetInstanceGuidResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_PartitionGetNameResponseTable;
+
+class Partition final {
+ Partition() = 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_partition_PartitionGetInfoResponseTable;
+ 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_partition_PartitionGetStatsResponseTable;
+ 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_partition_PartitionGetStatsRequestTable;
+ 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_partition_PartitionGetFifoResponseTable;
+ 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_partition_PartitionAttachVmoResponseTable;
+ 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_partition_PartitionAttachVmoRequestTable;
+ 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_partition_PartitionCloseFifoResponseTable;
+ 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_partition_PartitionRebindDeviceResponseTable;
+ 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_partition_PartitionGetTypeGuidResponseTable;
+ 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_partition_PartitionGetInstanceGuidResponseTable;
+ 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_partition_PartitionGetNameResponseTable;
+ 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;
+
+
+ // 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*;
+ };
+
+ 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>;
+ };
+
+ // 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*;
+ };
+
+ 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>;
+ };
+
+ 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);
+
+ 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);
+
+ };
+
+ // 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);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Partition;
+ 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;
+
+ };
+
+ // 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<Partition::GetInfoRequest>& _msg);
+ static void GetInfoResponse(const ::fidl::DecodedMessage<Partition::GetInfoResponse>& _msg);
+ static void GetStatsRequest(const ::fidl::DecodedMessage<Partition::GetStatsRequest>& _msg);
+ static void GetStatsResponse(const ::fidl::DecodedMessage<Partition::GetStatsResponse>& _msg);
+ static void GetFifoRequest(const ::fidl::DecodedMessage<Partition::GetFifoRequest>& _msg);
+ static void GetFifoResponse(const ::fidl::DecodedMessage<Partition::GetFifoResponse>& _msg);
+ static void AttachVmoRequest(const ::fidl::DecodedMessage<Partition::AttachVmoRequest>& _msg);
+ static void AttachVmoResponse(const ::fidl::DecodedMessage<Partition::AttachVmoResponse>& _msg);
+ static void CloseFifoRequest(const ::fidl::DecodedMessage<Partition::CloseFifoRequest>& _msg);
+ static void CloseFifoResponse(const ::fidl::DecodedMessage<Partition::CloseFifoResponse>& _msg);
+ static void RebindDeviceRequest(const ::fidl::DecodedMessage<Partition::RebindDeviceRequest>& _msg);
+ static void RebindDeviceResponse(const ::fidl::DecodedMessage<Partition::RebindDeviceResponse>& _msg);
+ static void GetTypeGuidRequest(const ::fidl::DecodedMessage<Partition::GetTypeGuidRequest>& _msg);
+ static void GetTypeGuidResponse(const ::fidl::DecodedMessage<Partition::GetTypeGuidResponse>& _msg);
+ static void GetInstanceGuidRequest(const ::fidl::DecodedMessage<Partition::GetInstanceGuidRequest>& _msg);
+ static void GetInstanceGuidResponse(const ::fidl::DecodedMessage<Partition::GetInstanceGuidResponse>& _msg);
+ static void GetNameRequest(const ::fidl::DecodedMessage<Partition::GetNameRequest>& _msg);
+ static void GetNameResponse(const ::fidl::DecodedMessage<Partition::GetNameResponse>& _msg);
+ };
+};
+
+constexpr uint32_t NAME_LENGTH = 128u;
+
+constexpr uint32_t GUID_LENGTH = 16u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_partition_GUIDTable;
+
+struct GUID {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_partition_GUIDTable;
+ 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;
+
+ ::fidl::Array<uint8_t, 16> value = {};
+};
+
+} // namespace partition
+} // namespace block
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::GetInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::GetInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::GetInfoResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::GetInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetInfoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetInfoResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsRequest)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsRequest, clear) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetStatsResponse, stats) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::GetFifoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::GetFifoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::GetFifoResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::GetFifoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetFifoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetFifoResponse, fifo) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoRequest)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoRequest, vmo) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::AttachVmoResponse, vmoid) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::CloseFifoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::CloseFifoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::CloseFifoResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::CloseFifoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::CloseFifoResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::RebindDeviceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::RebindDeviceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::RebindDeviceResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::RebindDeviceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::RebindDeviceResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::GetTypeGuidResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::GetTypeGuidResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::GetTypeGuidResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::GetTypeGuidResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetTypeGuidResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetTypeGuidResponse, guid) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::GetInstanceGuidResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::GetInstanceGuidResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::GetInstanceGuidResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::GetInstanceGuidResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetInstanceGuidResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetInstanceGuidResponse, guid) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::Partition::GetNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::partition::Partition::GetNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::Partition::GetNameResponse)
+ == ::llcpp::fuchsia::hardware::block::partition::Partition::GetNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetNameResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::Partition::GetNameResponse, name) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::partition::GUID> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::block::partition::GUID>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::partition::GUID, value) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::partition::GUID) == ::llcpp::fuchsia::hardware::block::partition::GUID::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-block-volume/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-block-volume/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..09601a7
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-block-volume/gen/llcpp/fidl.cc
@@ -0,0 +1,2463 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/block/volume/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace block {
+namespace volume {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetInfo_Ordinal = 0x7279049800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetInfo_GenOrdinal = 0x79df1a5cdb6cc6a3lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetStats_Ordinal = 0x73b9275400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetStats_GenOrdinal = 0x53d9542a778385aelu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetStatsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetFifo_Ordinal = 0x63616dbe00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetFifo_GenOrdinal = 0x507ea563fb50747elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetFifoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_AttachVmo_Ordinal = 0x72df2e6600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_AttachVmo_GenOrdinal = 0x7e726e5993add9b7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeAttachVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeAttachVmoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_CloseFifo_Ordinal = 0x6b4a461300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_CloseFifo_GenOrdinal = 0x4dc09acdfa2a2a65lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeCloseFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeCloseFifoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_RebindDevice_Ordinal = 0x2c1ffdb000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_RebindDevice_GenOrdinal = 0x5d728cbd5312c9aelu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeRebindDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeRebindDeviceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetTypeGuid_Ordinal = 0x40d3186c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetTypeGuid_GenOrdinal = 0x111843d737a9b847lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetTypeGuidRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetTypeGuidResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetInstanceGuid_Ordinal = 0x69f426600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetInstanceGuid_GenOrdinal = 0x14a5a573b275d435lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInstanceGuidRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetInstanceGuidResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetName_Ordinal = 0x39b49c4000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_GetName_GenOrdinal = 0x7e3c6f0b0937fc02lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeGetNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_Query_Ordinal = 0x40fc59f400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_Query_GenOrdinal = 0x5e1ac5124112e9aclu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQueryRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQueryResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_QuerySlices_Ordinal = 0x62b0f14900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_QuerySlices_GenOrdinal = 0x589a96828a3e2aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQuerySlicesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeQuerySlicesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_Extend_Ordinal = 0xa64d1b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_Extend_GenOrdinal = 0xdddf872f5039d37lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeExtendRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeExtendResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_Shrink_Ordinal = 0x761d12600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_Shrink_GenOrdinal = 0x27ab5ed4f6fdcd29lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeShrinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeShrinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolume_Destroy_Ordinal = 0x196549ea00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolume_Destroy_GenOrdinal = 0x732bf4bea39b5e87lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeDestroyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeDestroyResponseTable;
+
+} // namespace
+template <>
+Volume::ResultOf::GetInfo_Impl<Volume::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::GetInfo Volume::SyncClient::GetInfo() {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::GetInfo Volume::Call::GetInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInfo(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::GetInfo_Impl<Volume::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::GetInfo Volume::SyncClient::GetInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::GetInfo Volume::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::GetInfoResponse> Volume::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInfoRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::GetStats_Impl<Volume::GetStatsResponse>::GetStats_Impl(::zx::unowned_channel _client_end, bool clear) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStatsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStatsRequest*>(_write_bytes);
+ _request.clear = std::move(clear);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStatsRequest));
+ ::fidl::DecodedMessage<GetStatsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Volume::ResultOf::GetStats Volume::SyncClient::GetStats(bool clear) {
+ return ResultOf::GetStats(::zx::unowned_channel(this->channel_), std::move(clear));
+}
+
+Volume::ResultOf::GetStats Volume::Call::GetStats(::zx::unowned_channel _client_end, bool clear) {
+ return ResultOf::GetStats(std::move(_client_end), std::move(clear));
+}
+
+template <>
+Volume::UnownedResultOf::GetStats_Impl<Volume::GetStatsResponse>::GetStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetStatsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetStatsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetStatsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStatsRequest*>(_request_buffer.data());
+ _request.clear = std::move(clear);
+ _request_buffer.set_actual(sizeof(GetStatsRequest));
+ ::fidl::DecodedMessage<GetStatsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::GetStats Volume::SyncClient::GetStats(::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStats(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(clear), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::GetStats Volume::Call::GetStats(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStats(std::move(_client_end), std::move(_request_buffer), std::move(clear), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::GetStatsResponse> Volume::InPlace::GetStats(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStatsRequest> params, ::fidl::BytePart response_buffer) {
+ Volume::SetTransactionHeaderFor::GetStatsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetStatsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStatsRequest, GetStatsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetStatsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::GetFifo_Impl<Volume::GetFifoResponse>::GetFifo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFifoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFifoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFifoRequest));
+ ::fidl::DecodedMessage<GetFifoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::GetFifo(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::GetFifo Volume::SyncClient::GetFifo() {
+ return ResultOf::GetFifo(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::GetFifo Volume::Call::GetFifo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFifo(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::GetFifo_Impl<Volume::GetFifoResponse>::GetFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFifoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFifoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFifoRequest));
+ ::fidl::DecodedMessage<GetFifoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::GetFifo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::GetFifo Volume::SyncClient::GetFifo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFifo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::GetFifo Volume::Call::GetFifo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFifo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::GetFifoResponse> Volume::InPlace::GetFifo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFifoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFifoRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::GetFifoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetFifoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFifoRequest, GetFifoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetFifoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::AttachVmo_Impl<Volume::AttachVmoResponse>::AttachVmo_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AttachVmoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AttachVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AttachVmoRequest*>(_write_bytes);
+ _request.vmo = std::move(vmo);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AttachVmoRequest));
+ ::fidl::DecodedMessage<AttachVmoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Volume::ResultOf::AttachVmo Volume::SyncClient::AttachVmo(::zx::vmo vmo) {
+ return ResultOf::AttachVmo(::zx::unowned_channel(this->channel_), std::move(vmo));
+}
+
+Volume::ResultOf::AttachVmo Volume::Call::AttachVmo(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ return ResultOf::AttachVmo(std::move(_client_end), std::move(vmo));
+}
+
+template <>
+Volume::UnownedResultOf::AttachVmo_Impl<Volume::AttachVmoResponse>::AttachVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AttachVmoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AttachVmoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AttachVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AttachVmoRequest*>(_request_buffer.data());
+ _request.vmo = std::move(vmo);
+ _request_buffer.set_actual(sizeof(AttachVmoRequest));
+ ::fidl::DecodedMessage<AttachVmoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::AttachVmo Volume::SyncClient::AttachVmo(::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AttachVmo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::AttachVmo Volume::Call::AttachVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AttachVmo(std::move(_client_end), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::AttachVmoResponse> Volume::InPlace::AttachVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AttachVmoRequest> params, ::fidl::BytePart response_buffer) {
+ Volume::SetTransactionHeaderFor::AttachVmoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::AttachVmoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AttachVmoRequest, AttachVmoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::AttachVmoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::CloseFifo_Impl<Volume::CloseFifoResponse>::CloseFifo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseFifoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseFifoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseFifoRequest));
+ ::fidl::DecodedMessage<CloseFifoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::CloseFifo(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::CloseFifo Volume::SyncClient::CloseFifo() {
+ return ResultOf::CloseFifo(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::CloseFifo Volume::Call::CloseFifo(::zx::unowned_channel _client_end) {
+ return ResultOf::CloseFifo(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::CloseFifo_Impl<Volume::CloseFifoResponse>::CloseFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseFifoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseFifoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseFifoRequest));
+ ::fidl::DecodedMessage<CloseFifoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::CloseFifo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::CloseFifo Volume::SyncClient::CloseFifo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CloseFifo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::CloseFifo Volume::Call::CloseFifo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CloseFifo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::CloseFifoResponse> Volume::InPlace::CloseFifo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseFifoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseFifoRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::CloseFifoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::CloseFifoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseFifoRequest, CloseFifoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::CloseFifoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::RebindDevice_Impl<Volume::RebindDeviceResponse>::RebindDevice_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RebindDeviceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RebindDeviceRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RebindDeviceRequest));
+ ::fidl::DecodedMessage<RebindDeviceRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::RebindDevice(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::RebindDevice Volume::SyncClient::RebindDevice() {
+ return ResultOf::RebindDevice(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::RebindDevice Volume::Call::RebindDevice(::zx::unowned_channel _client_end) {
+ return ResultOf::RebindDevice(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::RebindDevice_Impl<Volume::RebindDeviceResponse>::RebindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RebindDeviceRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, RebindDeviceRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(RebindDeviceRequest));
+ ::fidl::DecodedMessage<RebindDeviceRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::RebindDevice(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::RebindDevice Volume::SyncClient::RebindDevice(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RebindDevice(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::RebindDevice Volume::Call::RebindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RebindDevice(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::RebindDeviceResponse> Volume::InPlace::RebindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(RebindDeviceRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<RebindDeviceRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::RebindDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::RebindDeviceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RebindDeviceRequest, RebindDeviceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::RebindDeviceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::GetTypeGuid_Impl<Volume::GetTypeGuidResponse>::GetTypeGuid_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTypeGuidRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTypeGuidRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTypeGuidRequest));
+ ::fidl::DecodedMessage<GetTypeGuidRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::GetTypeGuid(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::GetTypeGuid Volume::SyncClient::GetTypeGuid() {
+ return ResultOf::GetTypeGuid(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::GetTypeGuid Volume::Call::GetTypeGuid(::zx::unowned_channel _client_end) {
+ return ResultOf::GetTypeGuid(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::GetTypeGuid_Impl<Volume::GetTypeGuidResponse>::GetTypeGuid_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTypeGuidRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTypeGuidRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTypeGuidRequest));
+ ::fidl::DecodedMessage<GetTypeGuidRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::GetTypeGuid(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::GetTypeGuid Volume::SyncClient::GetTypeGuid(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTypeGuid(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::GetTypeGuid Volume::Call::GetTypeGuid(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTypeGuid(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::GetTypeGuidResponse> Volume::InPlace::GetTypeGuid(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTypeGuidRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTypeGuidRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::GetTypeGuidRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetTypeGuidResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTypeGuidRequest, GetTypeGuidResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetTypeGuidResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::GetInstanceGuid_Impl<Volume::GetInstanceGuidResponse>::GetInstanceGuid_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInstanceGuidRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInstanceGuidRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInstanceGuidRequest));
+ ::fidl::DecodedMessage<GetInstanceGuidRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::GetInstanceGuid(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::GetInstanceGuid Volume::SyncClient::GetInstanceGuid() {
+ return ResultOf::GetInstanceGuid(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::GetInstanceGuid Volume::Call::GetInstanceGuid(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInstanceGuid(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::GetInstanceGuid_Impl<Volume::GetInstanceGuidResponse>::GetInstanceGuid_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInstanceGuidRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInstanceGuidRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInstanceGuidRequest));
+ ::fidl::DecodedMessage<GetInstanceGuidRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::GetInstanceGuid(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::GetInstanceGuid Volume::SyncClient::GetInstanceGuid(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInstanceGuid(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::GetInstanceGuid Volume::Call::GetInstanceGuid(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInstanceGuid(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::GetInstanceGuidResponse> Volume::InPlace::GetInstanceGuid(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInstanceGuidRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInstanceGuidRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::GetInstanceGuidRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetInstanceGuidResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInstanceGuidRequest, GetInstanceGuidResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetInstanceGuidResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::GetName_Impl<Volume::GetNameResponse>::GetName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNameRequest));
+ ::fidl::DecodedMessage<GetNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::GetName(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::GetName Volume::SyncClient::GetName() {
+ return ResultOf::GetName(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::GetName Volume::Call::GetName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetName(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::GetName_Impl<Volume::GetNameResponse>::GetName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetNameRequest));
+ ::fidl::DecodedMessage<GetNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::GetName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::GetName Volume::SyncClient::GetName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::GetName Volume::Call::GetName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::GetNameResponse> Volume::InPlace::GetName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetNameRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::GetNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNameRequest, GetNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::GetNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::Query_Impl<Volume::QueryResponse>::Query_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, QueryRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(QueryRequest));
+ ::fidl::DecodedMessage<QueryRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::Query(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::Query Volume::SyncClient::Query() {
+ return ResultOf::Query(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::Query Volume::Call::Query(::zx::unowned_channel _client_end) {
+ return ResultOf::Query(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::Query_Impl<Volume::QueryResponse>::Query_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(QueryRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, QueryRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(QueryRequest));
+ ::fidl::DecodedMessage<QueryRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::Query(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::Query Volume::SyncClient::Query(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Query(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::Query Volume::Call::Query(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Query(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::QueryResponse> Volume::InPlace::Query(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(QueryRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<QueryRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::QueryRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::QueryResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<QueryRequest, QueryResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::QueryResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::QuerySlices_Impl<Volume::QuerySlicesResponse>::QuerySlices_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint64_t> start_slices) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QuerySlicesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ QuerySlicesRequest _request = {};
+ _request.start_slices = std::move(start_slices);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<QuerySlicesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Volume::InPlace::QuerySlices(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Volume::ResultOf::QuerySlices Volume::SyncClient::QuerySlices(::fidl::VectorView<uint64_t> start_slices) {
+ return ResultOf::QuerySlices(::zx::unowned_channel(this->channel_), std::move(start_slices));
+}
+
+Volume::ResultOf::QuerySlices Volume::Call::QuerySlices(::zx::unowned_channel _client_end, ::fidl::VectorView<uint64_t> start_slices) {
+ return ResultOf::QuerySlices(std::move(_client_end), std::move(start_slices));
+}
+
+template <>
+Volume::UnownedResultOf::QuerySlices_Impl<Volume::QuerySlicesResponse>::QuerySlices_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < QuerySlicesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<QuerySlicesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ QuerySlicesRequest _request = {};
+ _request.start_slices = std::move(start_slices);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<QuerySlicesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Volume::InPlace::QuerySlices(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::QuerySlices Volume::SyncClient::QuerySlices(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::QuerySlices(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(start_slices), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::QuerySlices Volume::Call::QuerySlices(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint64_t> start_slices, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::QuerySlices(std::move(_client_end), std::move(_request_buffer), std::move(start_slices), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::QuerySlicesResponse> Volume::InPlace::QuerySlices(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<QuerySlicesRequest> params, ::fidl::BytePart response_buffer) {
+ Volume::SetTransactionHeaderFor::QuerySlicesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::QuerySlicesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<QuerySlicesRequest, QuerySlicesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::QuerySlicesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::Extend_Impl<Volume::ExtendResponse>::Extend_Impl(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ExtendRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ExtendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ExtendRequest*>(_write_bytes);
+ _request.start_slice = std::move(start_slice);
+ _request.slice_count = std::move(slice_count);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ExtendRequest));
+ ::fidl::DecodedMessage<ExtendRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::Extend(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Volume::ResultOf::Extend Volume::SyncClient::Extend(uint64_t start_slice, uint64_t slice_count) {
+ return ResultOf::Extend(::zx::unowned_channel(this->channel_), std::move(start_slice), std::move(slice_count));
+}
+
+Volume::ResultOf::Extend Volume::Call::Extend(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count) {
+ return ResultOf::Extend(std::move(_client_end), std::move(start_slice), std::move(slice_count));
+}
+
+template <>
+Volume::UnownedResultOf::Extend_Impl<Volume::ExtendResponse>::Extend_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ExtendRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ExtendResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ExtendRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ExtendRequest*>(_request_buffer.data());
+ _request.start_slice = std::move(start_slice);
+ _request.slice_count = std::move(slice_count);
+ _request_buffer.set_actual(sizeof(ExtendRequest));
+ ::fidl::DecodedMessage<ExtendRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::Extend(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::Extend Volume::SyncClient::Extend(::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Extend(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(start_slice), std::move(slice_count), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::Extend Volume::Call::Extend(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Extend(std::move(_client_end), std::move(_request_buffer), std::move(start_slice), std::move(slice_count), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::ExtendResponse> Volume::InPlace::Extend(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ExtendRequest> params, ::fidl::BytePart response_buffer) {
+ Volume::SetTransactionHeaderFor::ExtendRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::ExtendResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ExtendRequest, ExtendResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::ExtendResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::Shrink_Impl<Volume::ShrinkResponse>::Shrink_Impl(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShrinkRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ShrinkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ShrinkRequest*>(_write_bytes);
+ _request.start_slice = std::move(start_slice);
+ _request.slice_count = std::move(slice_count);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShrinkRequest));
+ ::fidl::DecodedMessage<ShrinkRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::Shrink(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Volume::ResultOf::Shrink Volume::SyncClient::Shrink(uint64_t start_slice, uint64_t slice_count) {
+ return ResultOf::Shrink(::zx::unowned_channel(this->channel_), std::move(start_slice), std::move(slice_count));
+}
+
+Volume::ResultOf::Shrink Volume::Call::Shrink(::zx::unowned_channel _client_end, uint64_t start_slice, uint64_t slice_count) {
+ return ResultOf::Shrink(std::move(_client_end), std::move(start_slice), std::move(slice_count));
+}
+
+template <>
+Volume::UnownedResultOf::Shrink_Impl<Volume::ShrinkResponse>::Shrink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ShrinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ShrinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ShrinkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ShrinkRequest*>(_request_buffer.data());
+ _request.start_slice = std::move(start_slice);
+ _request.slice_count = std::move(slice_count);
+ _request_buffer.set_actual(sizeof(ShrinkRequest));
+ ::fidl::DecodedMessage<ShrinkRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::Shrink(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::Shrink Volume::SyncClient::Shrink(::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Shrink(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(start_slice), std::move(slice_count), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::Shrink Volume::Call::Shrink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t start_slice, uint64_t slice_count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Shrink(std::move(_client_end), std::move(_request_buffer), std::move(start_slice), std::move(slice_count), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::ShrinkResponse> Volume::InPlace::Shrink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ShrinkRequest> params, ::fidl::BytePart response_buffer) {
+ Volume::SetTransactionHeaderFor::ShrinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::ShrinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ShrinkRequest, ShrinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::ShrinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Volume::ResultOf::Destroy_Impl<Volume::DestroyResponse>::Destroy_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DestroyRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DestroyRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DestroyRequest));
+ ::fidl::DecodedMessage<DestroyRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Volume::InPlace::Destroy(std::move(_client_end), Super::response_buffer()));
+}
+
+Volume::ResultOf::Destroy Volume::SyncClient::Destroy() {
+ return ResultOf::Destroy(::zx::unowned_channel(this->channel_));
+}
+
+Volume::ResultOf::Destroy Volume::Call::Destroy(::zx::unowned_channel _client_end) {
+ return ResultOf::Destroy(std::move(_client_end));
+}
+
+template <>
+Volume::UnownedResultOf::Destroy_Impl<Volume::DestroyResponse>::Destroy_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DestroyRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DestroyRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DestroyRequest));
+ ::fidl::DecodedMessage<DestroyRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Volume::InPlace::Destroy(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Volume::UnownedResultOf::Destroy Volume::SyncClient::Destroy(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Destroy(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Volume::UnownedResultOf::Destroy Volume::Call::Destroy(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Destroy(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Volume::DestroyResponse> Volume::InPlace::Destroy(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DestroyRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DestroyRequest> params(std::move(_request_buffer));
+ Volume::SetTransactionHeaderFor::DestroyRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::DestroyResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DestroyRequest, DestroyResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Volume::DestroyResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Volume::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kVolume_GetInfo_Ordinal:
+ case kVolume_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInfo(
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_GetStats_Ordinal:
+ case kVolume_GetStats_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStatsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetStats(std::move(message->clear),
+ Interface::GetStatsCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_GetFifo_Ordinal:
+ case kVolume_GetFifo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFifoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFifo(
+ Interface::GetFifoCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_AttachVmo_Ordinal:
+ case kVolume_AttachVmo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AttachVmoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AttachVmo(std::move(message->vmo),
+ Interface::AttachVmoCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_CloseFifo_Ordinal:
+ case kVolume_CloseFifo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseFifoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->CloseFifo(
+ Interface::CloseFifoCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_RebindDevice_Ordinal:
+ case kVolume_RebindDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RebindDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->RebindDevice(
+ Interface::RebindDeviceCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_GetTypeGuid_Ordinal:
+ case kVolume_GetTypeGuid_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTypeGuidRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetTypeGuid(
+ Interface::GetTypeGuidCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_GetInstanceGuid_Ordinal:
+ case kVolume_GetInstanceGuid_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInstanceGuidRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInstanceGuid(
+ Interface::GetInstanceGuidCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_GetName_Ordinal:
+ case kVolume_GetName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetName(
+ Interface::GetNameCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_Query_Ordinal:
+ case kVolume_Query_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<QueryRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Query(
+ Interface::QueryCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_QuerySlices_Ordinal:
+ case kVolume_QuerySlices_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<QuerySlicesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->QuerySlices(std::move(message->start_slices),
+ Interface::QuerySlicesCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_Extend_Ordinal:
+ case kVolume_Extend_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ExtendRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Extend(std::move(message->start_slice), std::move(message->slice_count),
+ Interface::ExtendCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_Shrink_Ordinal:
+ case kVolume_Shrink_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ShrinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Shrink(std::move(message->start_slice), std::move(message->slice_count),
+ Interface::ShrinkCompleter::Sync(txn));
+ return true;
+ }
+ case kVolume_Destroy_Ordinal:
+ case kVolume_Destroy_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DestroyRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Destroy(
+ Interface::DestroyCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Volume::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Volume::Interface::GetInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInfoResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInfoResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ Volume::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::GetStatsCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetStatsResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetStatsResponse(
+ ::fidl::DecodedMessage<GetStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatsResponse::PrimarySize,
+ GetStatsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetStatsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats) {
+ if (_buffer.capacity() < GetStatsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetStatsResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetStatsResponse(
+ ::fidl::DecodedMessage<GetStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatsResponse::PrimarySize,
+ GetStatsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetStatsCompleterBase::Reply(::fidl::DecodedMessage<GetStatsResponse> params) {
+ Volume::SetTransactionHeaderFor::GetStatsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::GetFifoCompleterBase::Reply(int32_t status, ::zx::fifo fifo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFifoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetFifoResponse*>(_write_bytes);
+ Volume::SetTransactionHeaderFor::GetFifoResponse(
+ ::fidl::DecodedMessage<GetFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFifoResponse::PrimarySize,
+ GetFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.fifo = std::move(fifo);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFifoResponse>(std::move(_response_bytes)));
+}
+
+void Volume::Interface::GetFifoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::fifo fifo) {
+ if (_buffer.capacity() < GetFifoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetFifoResponse*>(_buffer.data());
+ Volume::SetTransactionHeaderFor::GetFifoResponse(
+ ::fidl::DecodedMessage<GetFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFifoResponse::PrimarySize,
+ GetFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.fifo = std::move(fifo);
+ _buffer.set_actual(sizeof(GetFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFifoResponse>(std::move(_buffer)));
+}
+
+void Volume::Interface::GetFifoCompleterBase::Reply(::fidl::DecodedMessage<GetFifoResponse> params) {
+ Volume::SetTransactionHeaderFor::GetFifoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::AttachVmoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AttachVmoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AttachVmoResponse _response = {};
+ Volume::SetTransactionHeaderFor::AttachVmoResponse(
+ ::fidl::DecodedMessage<AttachVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AttachVmoResponse::PrimarySize,
+ AttachVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.vmoid = std::move(vmoid);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::AttachVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid) {
+ if (_buffer.capacity() < AttachVmoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AttachVmoResponse _response = {};
+ Volume::SetTransactionHeaderFor::AttachVmoResponse(
+ ::fidl::DecodedMessage<AttachVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AttachVmoResponse::PrimarySize,
+ AttachVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.vmoid = std::move(vmoid);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::AttachVmoCompleterBase::Reply(::fidl::DecodedMessage<AttachVmoResponse> params) {
+ Volume::SetTransactionHeaderFor::AttachVmoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::CloseFifoCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseFifoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseFifoResponse*>(_write_bytes);
+ Volume::SetTransactionHeaderFor::CloseFifoResponse(
+ ::fidl::DecodedMessage<CloseFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseFifoResponse::PrimarySize,
+ CloseFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseFifoResponse>(std::move(_response_bytes)));
+}
+
+void Volume::Interface::CloseFifoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < CloseFifoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseFifoResponse*>(_buffer.data());
+ Volume::SetTransactionHeaderFor::CloseFifoResponse(
+ ::fidl::DecodedMessage<CloseFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseFifoResponse::PrimarySize,
+ CloseFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CloseFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseFifoResponse>(std::move(_buffer)));
+}
+
+void Volume::Interface::CloseFifoCompleterBase::Reply(::fidl::DecodedMessage<CloseFifoResponse> params) {
+ Volume::SetTransactionHeaderFor::CloseFifoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::RebindDeviceCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RebindDeviceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RebindDeviceResponse*>(_write_bytes);
+ Volume::SetTransactionHeaderFor::RebindDeviceResponse(
+ ::fidl::DecodedMessage<RebindDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RebindDeviceResponse::PrimarySize,
+ RebindDeviceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RebindDeviceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RebindDeviceResponse>(std::move(_response_bytes)));
+}
+
+void Volume::Interface::RebindDeviceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < RebindDeviceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RebindDeviceResponse*>(_buffer.data());
+ Volume::SetTransactionHeaderFor::RebindDeviceResponse(
+ ::fidl::DecodedMessage<RebindDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RebindDeviceResponse::PrimarySize,
+ RebindDeviceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(RebindDeviceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RebindDeviceResponse>(std::move(_buffer)));
+}
+
+void Volume::Interface::RebindDeviceCompleterBase::Reply(::fidl::DecodedMessage<RebindDeviceResponse> params) {
+ Volume::SetTransactionHeaderFor::RebindDeviceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::GetTypeGuidCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTypeGuidResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetTypeGuidResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetTypeGuidResponse(
+ ::fidl::DecodedMessage<GetTypeGuidResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTypeGuidResponse::PrimarySize,
+ GetTypeGuidResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.guid = std::move(guid);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetTypeGuidCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
+ if (_buffer.capacity() < GetTypeGuidResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTypeGuidResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetTypeGuidResponse(
+ ::fidl::DecodedMessage<GetTypeGuidResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTypeGuidResponse::PrimarySize,
+ GetTypeGuidResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.guid = std::move(guid);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetTypeGuidCompleterBase::Reply(::fidl::DecodedMessage<GetTypeGuidResponse> params) {
+ Volume::SetTransactionHeaderFor::GetTypeGuidResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::GetInstanceGuidCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInstanceGuidResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInstanceGuidResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetInstanceGuidResponse(
+ ::fidl::DecodedMessage<GetInstanceGuidResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInstanceGuidResponse::PrimarySize,
+ GetInstanceGuidResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.guid = std::move(guid);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetInstanceGuidCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::partition::GUID* guid) {
+ if (_buffer.capacity() < GetInstanceGuidResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInstanceGuidResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetInstanceGuidResponse(
+ ::fidl::DecodedMessage<GetInstanceGuidResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInstanceGuidResponse::PrimarySize,
+ GetInstanceGuidResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.guid = std::move(guid);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetInstanceGuidCompleterBase::Reply(::fidl::DecodedMessage<GetInstanceGuidResponse> params) {
+ Volume::SetTransactionHeaderFor::GetInstanceGuidResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::GetNameCompleterBase::Reply(int32_t status, ::fidl::StringView name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetNameResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetNameResponse(
+ ::fidl::DecodedMessage<GetNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNameResponse::PrimarySize,
+ GetNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetNameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::StringView name) {
+ if (_buffer.capacity() < GetNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetNameResponse _response = {};
+ Volume::SetTransactionHeaderFor::GetNameResponse(
+ ::fidl::DecodedMessage<GetNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNameResponse::PrimarySize,
+ GetNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::GetNameCompleterBase::Reply(::fidl::DecodedMessage<GetNameResponse> params) {
+ Volume::SetTransactionHeaderFor::GetNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::QueryCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ QueryResponse _response = {};
+ Volume::SetTransactionHeaderFor::QueryResponse(
+ ::fidl::DecodedMessage<QueryResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryResponse::PrimarySize,
+ QueryResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::QueryCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info) {
+ if (_buffer.capacity() < QueryResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ QueryResponse _response = {};
+ Volume::SetTransactionHeaderFor::QueryResponse(
+ ::fidl::DecodedMessage<QueryResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryResponse::PrimarySize,
+ QueryResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Volume::Interface::QueryCompleterBase::Reply(::fidl::DecodedMessage<QueryResponse> params) {
+ Volume::SetTransactionHeaderFor::QueryResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::QuerySlicesCompleterBase::Reply(int32_t status, ::fidl::Array<::llcpp::fuchsia::hardware::block::volume::VsliceRange, 16> response, uint64_t response_count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QuerySlicesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<QuerySlicesResponse*>(_write_bytes);
+ Volume::SetTransactionHeaderFor::QuerySlicesResponse(
+ ::fidl::DecodedMessage<QuerySlicesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QuerySlicesResponse::PrimarySize,
+ QuerySlicesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.response = std::move(response);
+ _response.response_count = std::move(response_count);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(QuerySlicesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<QuerySlicesResponse>(std::move(_response_bytes)));
+}
+
+void Volume::Interface::QuerySlicesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::Array<::llcpp::fuchsia::hardware::block::volume::VsliceRange, 16> response, uint64_t response_count) {
+ if (_buffer.capacity() < QuerySlicesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<QuerySlicesResponse*>(_buffer.data());
+ Volume::SetTransactionHeaderFor::QuerySlicesResponse(
+ ::fidl::DecodedMessage<QuerySlicesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QuerySlicesResponse::PrimarySize,
+ QuerySlicesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.response = std::move(response);
+ _response.response_count = std::move(response_count);
+ _buffer.set_actual(sizeof(QuerySlicesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<QuerySlicesResponse>(std::move(_buffer)));
+}
+
+void Volume::Interface::QuerySlicesCompleterBase::Reply(::fidl::DecodedMessage<QuerySlicesResponse> params) {
+ Volume::SetTransactionHeaderFor::QuerySlicesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::ExtendCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ExtendResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ExtendResponse*>(_write_bytes);
+ Volume::SetTransactionHeaderFor::ExtendResponse(
+ ::fidl::DecodedMessage<ExtendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ExtendResponse::PrimarySize,
+ ExtendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ExtendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ExtendResponse>(std::move(_response_bytes)));
+}
+
+void Volume::Interface::ExtendCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ExtendResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ExtendResponse*>(_buffer.data());
+ Volume::SetTransactionHeaderFor::ExtendResponse(
+ ::fidl::DecodedMessage<ExtendResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ExtendResponse::PrimarySize,
+ ExtendResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ExtendResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ExtendResponse>(std::move(_buffer)));
+}
+
+void Volume::Interface::ExtendCompleterBase::Reply(::fidl::DecodedMessage<ExtendResponse> params) {
+ Volume::SetTransactionHeaderFor::ExtendResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::ShrinkCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShrinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ShrinkResponse*>(_write_bytes);
+ Volume::SetTransactionHeaderFor::ShrinkResponse(
+ ::fidl::DecodedMessage<ShrinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ShrinkResponse::PrimarySize,
+ ShrinkResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShrinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ShrinkResponse>(std::move(_response_bytes)));
+}
+
+void Volume::Interface::ShrinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ShrinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ShrinkResponse*>(_buffer.data());
+ Volume::SetTransactionHeaderFor::ShrinkResponse(
+ ::fidl::DecodedMessage<ShrinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ShrinkResponse::PrimarySize,
+ ShrinkResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ShrinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ShrinkResponse>(std::move(_buffer)));
+}
+
+void Volume::Interface::ShrinkCompleterBase::Reply(::fidl::DecodedMessage<ShrinkResponse> params) {
+ Volume::SetTransactionHeaderFor::ShrinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Volume::Interface::DestroyCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DestroyResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DestroyResponse*>(_write_bytes);
+ Volume::SetTransactionHeaderFor::DestroyResponse(
+ ::fidl::DecodedMessage<DestroyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DestroyResponse::PrimarySize,
+ DestroyResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DestroyResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DestroyResponse>(std::move(_response_bytes)));
+}
+
+void Volume::Interface::DestroyCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < DestroyResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DestroyResponse*>(_buffer.data());
+ Volume::SetTransactionHeaderFor::DestroyResponse(
+ ::fidl::DecodedMessage<DestroyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DestroyResponse::PrimarySize,
+ DestroyResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(DestroyResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DestroyResponse>(std::move(_buffer)));
+}
+
+void Volume::Interface::DestroyCompleterBase::Reply(::fidl::DecodedMessage<DestroyResponse> params) {
+ Volume::SetTransactionHeaderFor::DestroyResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Volume::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<Volume::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<Volume::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::GetStatsRequest(const ::fidl::DecodedMessage<Volume::GetStatsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::GetStatsResponse(const ::fidl::DecodedMessage<Volume::GetStatsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::GetFifoRequest(const ::fidl::DecodedMessage<Volume::GetFifoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::GetFifoResponse(const ::fidl::DecodedMessage<Volume::GetFifoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::AttachVmoRequest(const ::fidl::DecodedMessage<Volume::AttachVmoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_AttachVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::AttachVmoResponse(const ::fidl::DecodedMessage<Volume::AttachVmoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_AttachVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::CloseFifoRequest(const ::fidl::DecodedMessage<Volume::CloseFifoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_CloseFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::CloseFifoResponse(const ::fidl::DecodedMessage<Volume::CloseFifoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_CloseFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::RebindDeviceRequest(const ::fidl::DecodedMessage<Volume::RebindDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_RebindDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::RebindDeviceResponse(const ::fidl::DecodedMessage<Volume::RebindDeviceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_RebindDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::GetTypeGuidRequest(const ::fidl::DecodedMessage<Volume::GetTypeGuidRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetTypeGuid_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::GetTypeGuidResponse(const ::fidl::DecodedMessage<Volume::GetTypeGuidResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetTypeGuid_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::GetInstanceGuidRequest(const ::fidl::DecodedMessage<Volume::GetInstanceGuidRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetInstanceGuid_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::GetInstanceGuidResponse(const ::fidl::DecodedMessage<Volume::GetInstanceGuidResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetInstanceGuid_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::GetNameRequest(const ::fidl::DecodedMessage<Volume::GetNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::GetNameResponse(const ::fidl::DecodedMessage<Volume::GetNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_GetName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::QueryRequest(const ::fidl::DecodedMessage<Volume::QueryRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_Query_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::QueryResponse(const ::fidl::DecodedMessage<Volume::QueryResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_Query_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::QuerySlicesRequest(const ::fidl::DecodedMessage<Volume::QuerySlicesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_QuerySlices_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::QuerySlicesResponse(const ::fidl::DecodedMessage<Volume::QuerySlicesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_QuerySlices_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::ExtendRequest(const ::fidl::DecodedMessage<Volume::ExtendRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_Extend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::ExtendResponse(const ::fidl::DecodedMessage<Volume::ExtendResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_Extend_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::ShrinkRequest(const ::fidl::DecodedMessage<Volume::ShrinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_Shrink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::ShrinkResponse(const ::fidl::DecodedMessage<Volume::ShrinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_Shrink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Volume::SetTransactionHeaderFor::DestroyRequest(const ::fidl::DecodedMessage<Volume::DestroyRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_Destroy_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Volume::SetTransactionHeaderFor::DestroyResponse(const ::fidl::DecodedMessage<Volume::DestroyResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolume_Destroy_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kVolumeManager_AllocatePartition_Ordinal = 0x33fab3bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolumeManager_AllocatePartition_GenOrdinal = 0x4e79f24ed059e394lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerAllocatePartitionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerAllocatePartitionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolumeManager_Query_Ordinal = 0x4591d72f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolumeManager_Query_GenOrdinal = 0x7604167e7b72904flu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerQueryRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerQueryResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolumeManager_GetInfo_Ordinal = 0x21196e0c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolumeManager_GetInfo_GenOrdinal = 0x735b3548582b2c9lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerGetInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kVolumeManager_Activate_Ordinal = 0x45f8979b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kVolumeManager_Activate_GenOrdinal = 0xc8cef57012874d0lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerActivateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_volume_VolumeManagerActivateResponseTable;
+
+} // namespace
+template <>
+VolumeManager::ResultOf::AllocatePartition_Impl<VolumeManager::AllocatePartitionResponse>::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) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocatePartitionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ AllocatePartitionRequest _request = {};
+ _request.slice_count = std::move(slice_count);
+ _request.type = std::move(type);
+ _request.instance = std::move(instance);
+ _request.name = std::move(name);
+ _request.flags = std::move(flags);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AllocatePartitionRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ VolumeManager::InPlace::AllocatePartition(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+VolumeManager::ResultOf::AllocatePartition VolumeManager::SyncClient::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) {
+ return ResultOf::AllocatePartition(::zx::unowned_channel(this->channel_), std::move(slice_count), std::move(type), std::move(instance), std::move(name), std::move(flags));
+}
+
+VolumeManager::ResultOf::AllocatePartition VolumeManager::Call::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) {
+ return ResultOf::AllocatePartition(std::move(_client_end), std::move(slice_count), std::move(type), std::move(instance), std::move(name), std::move(flags));
+}
+
+template <>
+VolumeManager::UnownedResultOf::AllocatePartition_Impl<VolumeManager::AllocatePartitionResponse>::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) {
+ if (_request_buffer.capacity() < AllocatePartitionRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AllocatePartitionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ AllocatePartitionRequest _request = {};
+ _request.slice_count = std::move(slice_count);
+ _request.type = std::move(type);
+ _request.instance = std::move(instance);
+ _request.name = std::move(name);
+ _request.flags = std::move(flags);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AllocatePartitionRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ VolumeManager::InPlace::AllocatePartition(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+VolumeManager::UnownedResultOf::AllocatePartition VolumeManager::SyncClient::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) {
+ return UnownedResultOf::AllocatePartition(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(slice_count), std::move(type), std::move(instance), std::move(name), std::move(flags), std::move(_response_buffer));
+}
+
+VolumeManager::UnownedResultOf::AllocatePartition VolumeManager::Call::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) {
+ return UnownedResultOf::AllocatePartition(std::move(_client_end), std::move(_request_buffer), std::move(slice_count), std::move(type), std::move(instance), std::move(name), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<VolumeManager::AllocatePartitionResponse> VolumeManager::InPlace::AllocatePartition(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocatePartitionRequest> params, ::fidl::BytePart response_buffer) {
+ VolumeManager::SetTransactionHeaderFor::AllocatePartitionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<VolumeManager::AllocatePartitionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AllocatePartitionRequest, AllocatePartitionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<VolumeManager::AllocatePartitionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+VolumeManager::ResultOf::Query_Impl<VolumeManager::QueryResponse>::Query_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, QueryRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(QueryRequest));
+ ::fidl::DecodedMessage<QueryRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ VolumeManager::InPlace::Query(std::move(_client_end), Super::response_buffer()));
+}
+
+VolumeManager::ResultOf::Query VolumeManager::SyncClient::Query() {
+ return ResultOf::Query(::zx::unowned_channel(this->channel_));
+}
+
+VolumeManager::ResultOf::Query VolumeManager::Call::Query(::zx::unowned_channel _client_end) {
+ return ResultOf::Query(std::move(_client_end));
+}
+
+template <>
+VolumeManager::UnownedResultOf::Query_Impl<VolumeManager::QueryResponse>::Query_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(QueryRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, QueryRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(QueryRequest));
+ ::fidl::DecodedMessage<QueryRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ VolumeManager::InPlace::Query(std::move(_client_end), std::move(_response_buffer)));
+}
+
+VolumeManager::UnownedResultOf::Query VolumeManager::SyncClient::Query(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Query(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+VolumeManager::UnownedResultOf::Query VolumeManager::Call::Query(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Query(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<VolumeManager::QueryResponse> VolumeManager::InPlace::Query(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(QueryRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<QueryRequest> params(std::move(_request_buffer));
+ VolumeManager::SetTransactionHeaderFor::QueryRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<VolumeManager::QueryResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<QueryRequest, QueryResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<VolumeManager::QueryResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+VolumeManager::ResultOf::GetInfo_Impl<VolumeManager::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ VolumeManager::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+VolumeManager::ResultOf::GetInfo VolumeManager::SyncClient::GetInfo() {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
+}
+
+VolumeManager::ResultOf::GetInfo VolumeManager::Call::GetInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInfo(std::move(_client_end));
+}
+
+template <>
+VolumeManager::UnownedResultOf::GetInfo_Impl<VolumeManager::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ VolumeManager::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+VolumeManager::UnownedResultOf::GetInfo VolumeManager::SyncClient::GetInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+VolumeManager::UnownedResultOf::GetInfo VolumeManager::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<VolumeManager::GetInfoResponse> VolumeManager::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInfoRequest> params(std::move(_request_buffer));
+ VolumeManager::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<VolumeManager::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<VolumeManager::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+VolumeManager::ResultOf::Activate_Impl<VolumeManager::ActivateResponse>::Activate_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ActivateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ActivateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ActivateRequest*>(_write_bytes);
+ _request.old_guid = std::move(old_guid);
+ _request.new_guid = std::move(new_guid);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ActivateRequest));
+ ::fidl::DecodedMessage<ActivateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ VolumeManager::InPlace::Activate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+VolumeManager::ResultOf::Activate VolumeManager::SyncClient::Activate(::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid) {
+ return ResultOf::Activate(::zx::unowned_channel(this->channel_), std::move(old_guid), std::move(new_guid));
+}
+
+VolumeManager::ResultOf::Activate VolumeManager::Call::Activate(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::block::partition::GUID old_guid, ::llcpp::fuchsia::hardware::block::partition::GUID new_guid) {
+ return ResultOf::Activate(std::move(_client_end), std::move(old_guid), std::move(new_guid));
+}
+
+template <>
+VolumeManager::UnownedResultOf::Activate_Impl<VolumeManager::ActivateResponse>::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) {
+ if (_request_buffer.capacity() < ActivateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ActivateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ActivateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ActivateRequest*>(_request_buffer.data());
+ _request.old_guid = std::move(old_guid);
+ _request.new_guid = std::move(new_guid);
+ _request_buffer.set_actual(sizeof(ActivateRequest));
+ ::fidl::DecodedMessage<ActivateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ VolumeManager::InPlace::Activate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+VolumeManager::UnownedResultOf::Activate VolumeManager::SyncClient::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) {
+ return UnownedResultOf::Activate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(old_guid), std::move(new_guid), std::move(_response_buffer));
+}
+
+VolumeManager::UnownedResultOf::Activate VolumeManager::Call::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) {
+ return UnownedResultOf::Activate(std::move(_client_end), std::move(_request_buffer), std::move(old_guid), std::move(new_guid), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<VolumeManager::ActivateResponse> VolumeManager::InPlace::Activate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ActivateRequest> params, ::fidl::BytePart response_buffer) {
+ VolumeManager::SetTransactionHeaderFor::ActivateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<VolumeManager::ActivateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ActivateRequest, ActivateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<VolumeManager::ActivateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool VolumeManager::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kVolumeManager_AllocatePartition_Ordinal:
+ case kVolumeManager_AllocatePartition_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AllocatePartitionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AllocatePartition(std::move(message->slice_count), std::move(message->type), std::move(message->instance), std::move(message->name), std::move(message->flags),
+ Interface::AllocatePartitionCompleter::Sync(txn));
+ return true;
+ }
+ case kVolumeManager_Query_Ordinal:
+ case kVolumeManager_Query_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<QueryRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Query(
+ Interface::QueryCompleter::Sync(txn));
+ return true;
+ }
+ case kVolumeManager_GetInfo_Ordinal:
+ case kVolumeManager_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInfo(
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kVolumeManager_Activate_Ordinal:
+ case kVolumeManager_Activate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ActivateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Activate(std::move(message->old_guid), std::move(message->new_guid),
+ Interface::ActivateCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool VolumeManager::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void VolumeManager::Interface::AllocatePartitionCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocatePartitionResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<AllocatePartitionResponse*>(_write_bytes);
+ VolumeManager::SetTransactionHeaderFor::AllocatePartitionResponse(
+ ::fidl::DecodedMessage<AllocatePartitionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AllocatePartitionResponse::PrimarySize,
+ AllocatePartitionResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AllocatePartitionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<AllocatePartitionResponse>(std::move(_response_bytes)));
+}
+
+void VolumeManager::Interface::AllocatePartitionCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < AllocatePartitionResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<AllocatePartitionResponse*>(_buffer.data());
+ VolumeManager::SetTransactionHeaderFor::AllocatePartitionResponse(
+ ::fidl::DecodedMessage<AllocatePartitionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AllocatePartitionResponse::PrimarySize,
+ AllocatePartitionResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(AllocatePartitionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<AllocatePartitionResponse>(std::move(_buffer)));
+}
+
+void VolumeManager::Interface::AllocatePartitionCompleterBase::Reply(::fidl::DecodedMessage<AllocatePartitionResponse> params) {
+ VolumeManager::SetTransactionHeaderFor::AllocatePartitionResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void VolumeManager::Interface::QueryCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ QueryResponse _response = {};
+ VolumeManager::SetTransactionHeaderFor::QueryResponse(
+ ::fidl::DecodedMessage<QueryResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryResponse::PrimarySize,
+ QueryResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void VolumeManager::Interface::QueryCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeInfo* info) {
+ if (_buffer.capacity() < QueryResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ QueryResponse _response = {};
+ VolumeManager::SetTransactionHeaderFor::QueryResponse(
+ ::fidl::DecodedMessage<QueryResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryResponse::PrimarySize,
+ QueryResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void VolumeManager::Interface::QueryCompleterBase::Reply(::fidl::DecodedMessage<QueryResponse> params) {
+ VolumeManager::SetTransactionHeaderFor::QueryResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void VolumeManager::Interface::GetInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInfoResponse _response = {};
+ VolumeManager::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void VolumeManager::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::volume::VolumeManagerInfo* info) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInfoResponse _response = {};
+ VolumeManager::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void VolumeManager::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ VolumeManager::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void VolumeManager::Interface::ActivateCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ActivateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ActivateResponse*>(_write_bytes);
+ VolumeManager::SetTransactionHeaderFor::ActivateResponse(
+ ::fidl::DecodedMessage<ActivateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ActivateResponse::PrimarySize,
+ ActivateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ActivateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ActivateResponse>(std::move(_response_bytes)));
+}
+
+void VolumeManager::Interface::ActivateCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ActivateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ActivateResponse*>(_buffer.data());
+ VolumeManager::SetTransactionHeaderFor::ActivateResponse(
+ ::fidl::DecodedMessage<ActivateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ActivateResponse::PrimarySize,
+ ActivateResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ActivateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ActivateResponse>(std::move(_buffer)));
+}
+
+void VolumeManager::Interface::ActivateCompleterBase::Reply(::fidl::DecodedMessage<ActivateResponse> params) {
+ VolumeManager::SetTransactionHeaderFor::ActivateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void VolumeManager::SetTransactionHeaderFor::AllocatePartitionRequest(const ::fidl::DecodedMessage<VolumeManager::AllocatePartitionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolumeManager_AllocatePartition_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void VolumeManager::SetTransactionHeaderFor::AllocatePartitionResponse(const ::fidl::DecodedMessage<VolumeManager::AllocatePartitionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolumeManager_AllocatePartition_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void VolumeManager::SetTransactionHeaderFor::QueryRequest(const ::fidl::DecodedMessage<VolumeManager::QueryRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolumeManager_Query_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void VolumeManager::SetTransactionHeaderFor::QueryResponse(const ::fidl::DecodedMessage<VolumeManager::QueryResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolumeManager_Query_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void VolumeManager::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<VolumeManager::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolumeManager_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void VolumeManager::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<VolumeManager::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolumeManager_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void VolumeManager::SetTransactionHeaderFor::ActivateRequest(const ::fidl::DecodedMessage<VolumeManager::ActivateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolumeManager_Activate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void VolumeManager::SetTransactionHeaderFor::ActivateResponse(const ::fidl::DecodedMessage<VolumeManager::ActivateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kVolumeManager_Activate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace volume
+} // namespace block
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-block-volume/gen/llcpp/include/fuchsia/hardware/block/volume/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-block-volume/gen/llcpp/include/fuchsia/hardware/block/volume/llcpp/fidl.h
new file mode 100644
index 0000000..3364da2
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-block-volume/gen/llcpp/include/fuchsia/hardware/block/volume/llcpp/fidl.h
@@ -0,0 +1,2154 @@
+// 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
diff --git a/zircon/system/fidl/fuchsia-hardware-block/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-block/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..d31b19a6
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-block/gen/llcpp/fidl.cc
@@ -0,0 +1,993 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/block/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace block {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kFtl_Format_Ordinal = 0x34f0c1b900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFtl_Format_GenOrdinal = 0x79751d9c0b48a0d6lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_FtlFormatRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_FtlFormatResponseTable;
+
+} // namespace
+template <>
+Ftl::ResultOf::Format_Impl<Ftl::FormatResponse>::Format_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FormatRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, FormatRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(FormatRequest));
+ ::fidl::DecodedMessage<FormatRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Ftl::InPlace::Format(std::move(_client_end), Super::response_buffer()));
+}
+
+Ftl::ResultOf::Format Ftl::SyncClient::Format() {
+ return ResultOf::Format(::zx::unowned_channel(this->channel_));
+}
+
+Ftl::ResultOf::Format Ftl::Call::Format(::zx::unowned_channel _client_end) {
+ return ResultOf::Format(std::move(_client_end));
+}
+
+template <>
+Ftl::UnownedResultOf::Format_Impl<Ftl::FormatResponse>::Format_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(FormatRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, FormatRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(FormatRequest));
+ ::fidl::DecodedMessage<FormatRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Ftl::InPlace::Format(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Ftl::UnownedResultOf::Format Ftl::SyncClient::Format(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Format(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Ftl::UnownedResultOf::Format Ftl::Call::Format(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Format(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Ftl::FormatResponse> Ftl::InPlace::Format(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(FormatRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<FormatRequest> params(std::move(_request_buffer));
+ Ftl::SetTransactionHeaderFor::FormatRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Ftl::FormatResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<FormatRequest, FormatResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Ftl::FormatResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Ftl::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kFtl_Format_Ordinal:
+ case kFtl_Format_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<FormatRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Format(
+ Interface::FormatCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Ftl::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Ftl::Interface::FormatCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FormatResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<FormatResponse*>(_write_bytes);
+ Ftl::SetTransactionHeaderFor::FormatResponse(
+ ::fidl::DecodedMessage<FormatResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ FormatResponse::PrimarySize,
+ FormatResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(FormatResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<FormatResponse>(std::move(_response_bytes)));
+}
+
+void Ftl::Interface::FormatCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < FormatResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<FormatResponse*>(_buffer.data());
+ Ftl::SetTransactionHeaderFor::FormatResponse(
+ ::fidl::DecodedMessage<FormatResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ FormatResponse::PrimarySize,
+ FormatResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(FormatResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<FormatResponse>(std::move(_buffer)));
+}
+
+void Ftl::Interface::FormatCompleterBase::Reply(::fidl::DecodedMessage<FormatResponse> params) {
+ Ftl::SetTransactionHeaderFor::FormatResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Ftl::SetTransactionHeaderFor::FormatRequest(const ::fidl::DecodedMessage<Ftl::FormatRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFtl_Format_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Ftl::SetTransactionHeaderFor::FormatResponse(const ::fidl::DecodedMessage<Ftl::FormatResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFtl_Format_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBlock_GetInfo_Ordinal = 0x7279049800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBlock_GetInfo_GenOrdinal = 0x79df1a5cdb6cc6a3lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBlock_GetStats_Ordinal = 0x73b9275400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBlock_GetStats_GenOrdinal = 0x53d9542a778385aelu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetStatsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBlock_GetFifo_Ordinal = 0x63616dbe00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBlock_GetFifo_GenOrdinal = 0x507ea563fb50747elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetFifoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBlock_AttachVmo_Ordinal = 0x72df2e6600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBlock_AttachVmo_GenOrdinal = 0x7e726e5993add9b7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockAttachVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockAttachVmoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBlock_CloseFifo_Ordinal = 0x6b4a461300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBlock_CloseFifo_GenOrdinal = 0x4dc09acdfa2a2a65lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockCloseFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockCloseFifoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBlock_RebindDevice_Ordinal = 0x2c1ffdb000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBlock_RebindDevice_GenOrdinal = 0x5d728cbd5312c9aelu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockRebindDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockRebindDeviceResponseTable;
+
+} // namespace
+template <>
+Block::ResultOf::GetInfo_Impl<Block::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Block::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Block::ResultOf::GetInfo Block::SyncClient::GetInfo() {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
+}
+
+Block::ResultOf::GetInfo Block::Call::GetInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInfo(std::move(_client_end));
+}
+
+template <>
+Block::UnownedResultOf::GetInfo_Impl<Block::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Block::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Block::UnownedResultOf::GetInfo Block::SyncClient::GetInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Block::UnownedResultOf::GetInfo Block::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Block::GetInfoResponse> Block::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInfoRequest> params(std::move(_request_buffer));
+ Block::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Block::ResultOf::GetStats_Impl<Block::GetStatsResponse>::GetStats_Impl(::zx::unowned_channel _client_end, bool clear) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStatsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStatsRequest*>(_write_bytes);
+ _request.clear = std::move(clear);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStatsRequest));
+ ::fidl::DecodedMessage<GetStatsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Block::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Block::ResultOf::GetStats Block::SyncClient::GetStats(bool clear) {
+ return ResultOf::GetStats(::zx::unowned_channel(this->channel_), std::move(clear));
+}
+
+Block::ResultOf::GetStats Block::Call::GetStats(::zx::unowned_channel _client_end, bool clear) {
+ return ResultOf::GetStats(std::move(_client_end), std::move(clear));
+}
+
+template <>
+Block::UnownedResultOf::GetStats_Impl<Block::GetStatsResponse>::GetStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetStatsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetStatsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetStatsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStatsRequest*>(_request_buffer.data());
+ _request.clear = std::move(clear);
+ _request_buffer.set_actual(sizeof(GetStatsRequest));
+ ::fidl::DecodedMessage<GetStatsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Block::InPlace::GetStats(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Block::UnownedResultOf::GetStats Block::SyncClient::GetStats(::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStats(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(clear), std::move(_response_buffer));
+}
+
+Block::UnownedResultOf::GetStats Block::Call::GetStats(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool clear, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStats(std::move(_client_end), std::move(_request_buffer), std::move(clear), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Block::GetStatsResponse> Block::InPlace::GetStats(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStatsRequest> params, ::fidl::BytePart response_buffer) {
+ Block::SetTransactionHeaderFor::GetStatsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::GetStatsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStatsRequest, GetStatsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::GetStatsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Block::ResultOf::GetFifo_Impl<Block::GetFifoResponse>::GetFifo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFifoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFifoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFifoRequest));
+ ::fidl::DecodedMessage<GetFifoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Block::InPlace::GetFifo(std::move(_client_end), Super::response_buffer()));
+}
+
+Block::ResultOf::GetFifo Block::SyncClient::GetFifo() {
+ return ResultOf::GetFifo(::zx::unowned_channel(this->channel_));
+}
+
+Block::ResultOf::GetFifo Block::Call::GetFifo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFifo(std::move(_client_end));
+}
+
+template <>
+Block::UnownedResultOf::GetFifo_Impl<Block::GetFifoResponse>::GetFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFifoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFifoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFifoRequest));
+ ::fidl::DecodedMessage<GetFifoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Block::InPlace::GetFifo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Block::UnownedResultOf::GetFifo Block::SyncClient::GetFifo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFifo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Block::UnownedResultOf::GetFifo Block::Call::GetFifo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFifo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Block::GetFifoResponse> Block::InPlace::GetFifo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFifoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFifoRequest> params(std::move(_request_buffer));
+ Block::SetTransactionHeaderFor::GetFifoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::GetFifoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFifoRequest, GetFifoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::GetFifoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Block::ResultOf::AttachVmo_Impl<Block::AttachVmoResponse>::AttachVmo_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AttachVmoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AttachVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AttachVmoRequest*>(_write_bytes);
+ _request.vmo = std::move(vmo);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AttachVmoRequest));
+ ::fidl::DecodedMessage<AttachVmoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Block::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Block::ResultOf::AttachVmo Block::SyncClient::AttachVmo(::zx::vmo vmo) {
+ return ResultOf::AttachVmo(::zx::unowned_channel(this->channel_), std::move(vmo));
+}
+
+Block::ResultOf::AttachVmo Block::Call::AttachVmo(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ return ResultOf::AttachVmo(std::move(_client_end), std::move(vmo));
+}
+
+template <>
+Block::UnownedResultOf::AttachVmo_Impl<Block::AttachVmoResponse>::AttachVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AttachVmoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AttachVmoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AttachVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AttachVmoRequest*>(_request_buffer.data());
+ _request.vmo = std::move(vmo);
+ _request_buffer.set_actual(sizeof(AttachVmoRequest));
+ ::fidl::DecodedMessage<AttachVmoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Block::InPlace::AttachVmo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Block::UnownedResultOf::AttachVmo Block::SyncClient::AttachVmo(::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AttachVmo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+Block::UnownedResultOf::AttachVmo Block::Call::AttachVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AttachVmo(std::move(_client_end), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Block::AttachVmoResponse> Block::InPlace::AttachVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AttachVmoRequest> params, ::fidl::BytePart response_buffer) {
+ Block::SetTransactionHeaderFor::AttachVmoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::AttachVmoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AttachVmoRequest, AttachVmoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::AttachVmoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Block::ResultOf::CloseFifo_Impl<Block::CloseFifoResponse>::CloseFifo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseFifoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseFifoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseFifoRequest));
+ ::fidl::DecodedMessage<CloseFifoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Block::InPlace::CloseFifo(std::move(_client_end), Super::response_buffer()));
+}
+
+Block::ResultOf::CloseFifo Block::SyncClient::CloseFifo() {
+ return ResultOf::CloseFifo(::zx::unowned_channel(this->channel_));
+}
+
+Block::ResultOf::CloseFifo Block::Call::CloseFifo(::zx::unowned_channel _client_end) {
+ return ResultOf::CloseFifo(std::move(_client_end));
+}
+
+template <>
+Block::UnownedResultOf::CloseFifo_Impl<Block::CloseFifoResponse>::CloseFifo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseFifoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseFifoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseFifoRequest));
+ ::fidl::DecodedMessage<CloseFifoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Block::InPlace::CloseFifo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Block::UnownedResultOf::CloseFifo Block::SyncClient::CloseFifo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CloseFifo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Block::UnownedResultOf::CloseFifo Block::Call::CloseFifo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CloseFifo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Block::CloseFifoResponse> Block::InPlace::CloseFifo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseFifoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseFifoRequest> params(std::move(_request_buffer));
+ Block::SetTransactionHeaderFor::CloseFifoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::CloseFifoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseFifoRequest, CloseFifoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::CloseFifoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Block::ResultOf::RebindDevice_Impl<Block::RebindDeviceResponse>::RebindDevice_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RebindDeviceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RebindDeviceRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RebindDeviceRequest));
+ ::fidl::DecodedMessage<RebindDeviceRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Block::InPlace::RebindDevice(std::move(_client_end), Super::response_buffer()));
+}
+
+Block::ResultOf::RebindDevice Block::SyncClient::RebindDevice() {
+ return ResultOf::RebindDevice(::zx::unowned_channel(this->channel_));
+}
+
+Block::ResultOf::RebindDevice Block::Call::RebindDevice(::zx::unowned_channel _client_end) {
+ return ResultOf::RebindDevice(std::move(_client_end));
+}
+
+template <>
+Block::UnownedResultOf::RebindDevice_Impl<Block::RebindDeviceResponse>::RebindDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RebindDeviceRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, RebindDeviceRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(RebindDeviceRequest));
+ ::fidl::DecodedMessage<RebindDeviceRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Block::InPlace::RebindDevice(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Block::UnownedResultOf::RebindDevice Block::SyncClient::RebindDevice(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RebindDevice(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Block::UnownedResultOf::RebindDevice Block::Call::RebindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RebindDevice(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Block::RebindDeviceResponse> Block::InPlace::RebindDevice(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(RebindDeviceRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<RebindDeviceRequest> params(std::move(_request_buffer));
+ Block::SetTransactionHeaderFor::RebindDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::RebindDeviceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RebindDeviceRequest, RebindDeviceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Block::RebindDeviceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Block::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBlock_GetInfo_Ordinal:
+ case kBlock_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInfo(
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kBlock_GetStats_Ordinal:
+ case kBlock_GetStats_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStatsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetStats(std::move(message->clear),
+ Interface::GetStatsCompleter::Sync(txn));
+ return true;
+ }
+ case kBlock_GetFifo_Ordinal:
+ case kBlock_GetFifo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFifoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFifo(
+ Interface::GetFifoCompleter::Sync(txn));
+ return true;
+ }
+ case kBlock_AttachVmo_Ordinal:
+ case kBlock_AttachVmo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AttachVmoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AttachVmo(std::move(message->vmo),
+ Interface::AttachVmoCompleter::Sync(txn));
+ return true;
+ }
+ case kBlock_CloseFifo_Ordinal:
+ case kBlock_CloseFifo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseFifoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->CloseFifo(
+ Interface::CloseFifoCompleter::Sync(txn));
+ return true;
+ }
+ case kBlock_RebindDevice_Ordinal:
+ case kBlock_RebindDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RebindDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->RebindDevice(
+ Interface::RebindDeviceCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Block::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Block::Interface::GetInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInfoResponse _response = {};
+ Block::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Block::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockInfo* info) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInfoResponse _response = {};
+ Block::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Block::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ Block::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Block::Interface::GetStatsCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetStatsResponse _response = {};
+ Block::SetTransactionHeaderFor::GetStatsResponse(
+ ::fidl::DecodedMessage<GetStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatsResponse::PrimarySize,
+ GetStatsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Block::Interface::GetStatsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::BlockStats* stats) {
+ if (_buffer.capacity() < GetStatsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetStatsResponse _response = {};
+ Block::SetTransactionHeaderFor::GetStatsResponse(
+ ::fidl::DecodedMessage<GetStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatsResponse::PrimarySize,
+ GetStatsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Block::Interface::GetStatsCompleterBase::Reply(::fidl::DecodedMessage<GetStatsResponse> params) {
+ Block::SetTransactionHeaderFor::GetStatsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Block::Interface::GetFifoCompleterBase::Reply(int32_t status, ::zx::fifo fifo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFifoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetFifoResponse*>(_write_bytes);
+ Block::SetTransactionHeaderFor::GetFifoResponse(
+ ::fidl::DecodedMessage<GetFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFifoResponse::PrimarySize,
+ GetFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.fifo = std::move(fifo);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFifoResponse>(std::move(_response_bytes)));
+}
+
+void Block::Interface::GetFifoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::fifo fifo) {
+ if (_buffer.capacity() < GetFifoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetFifoResponse*>(_buffer.data());
+ Block::SetTransactionHeaderFor::GetFifoResponse(
+ ::fidl::DecodedMessage<GetFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFifoResponse::PrimarySize,
+ GetFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.fifo = std::move(fifo);
+ _buffer.set_actual(sizeof(GetFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFifoResponse>(std::move(_buffer)));
+}
+
+void Block::Interface::GetFifoCompleterBase::Reply(::fidl::DecodedMessage<GetFifoResponse> params) {
+ Block::SetTransactionHeaderFor::GetFifoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Block::Interface::AttachVmoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AttachVmoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AttachVmoResponse _response = {};
+ Block::SetTransactionHeaderFor::AttachVmoResponse(
+ ::fidl::DecodedMessage<AttachVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AttachVmoResponse::PrimarySize,
+ AttachVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.vmoid = std::move(vmoid);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Block::Interface::AttachVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::block::VmoID* vmoid) {
+ if (_buffer.capacity() < AttachVmoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AttachVmoResponse _response = {};
+ Block::SetTransactionHeaderFor::AttachVmoResponse(
+ ::fidl::DecodedMessage<AttachVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AttachVmoResponse::PrimarySize,
+ AttachVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.vmoid = std::move(vmoid);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Block::Interface::AttachVmoCompleterBase::Reply(::fidl::DecodedMessage<AttachVmoResponse> params) {
+ Block::SetTransactionHeaderFor::AttachVmoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Block::Interface::CloseFifoCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseFifoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseFifoResponse*>(_write_bytes);
+ Block::SetTransactionHeaderFor::CloseFifoResponse(
+ ::fidl::DecodedMessage<CloseFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseFifoResponse::PrimarySize,
+ CloseFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseFifoResponse>(std::move(_response_bytes)));
+}
+
+void Block::Interface::CloseFifoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < CloseFifoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseFifoResponse*>(_buffer.data());
+ Block::SetTransactionHeaderFor::CloseFifoResponse(
+ ::fidl::DecodedMessage<CloseFifoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseFifoResponse::PrimarySize,
+ CloseFifoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CloseFifoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseFifoResponse>(std::move(_buffer)));
+}
+
+void Block::Interface::CloseFifoCompleterBase::Reply(::fidl::DecodedMessage<CloseFifoResponse> params) {
+ Block::SetTransactionHeaderFor::CloseFifoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Block::Interface::RebindDeviceCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RebindDeviceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RebindDeviceResponse*>(_write_bytes);
+ Block::SetTransactionHeaderFor::RebindDeviceResponse(
+ ::fidl::DecodedMessage<RebindDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RebindDeviceResponse::PrimarySize,
+ RebindDeviceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RebindDeviceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RebindDeviceResponse>(std::move(_response_bytes)));
+}
+
+void Block::Interface::RebindDeviceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < RebindDeviceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RebindDeviceResponse*>(_buffer.data());
+ Block::SetTransactionHeaderFor::RebindDeviceResponse(
+ ::fidl::DecodedMessage<RebindDeviceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RebindDeviceResponse::PrimarySize,
+ RebindDeviceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(RebindDeviceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RebindDeviceResponse>(std::move(_buffer)));
+}
+
+void Block::Interface::RebindDeviceCompleterBase::Reply(::fidl::DecodedMessage<RebindDeviceResponse> params) {
+ Block::SetTransactionHeaderFor::RebindDeviceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Block::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<Block::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Block::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<Block::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Block::SetTransactionHeaderFor::GetStatsRequest(const ::fidl::DecodedMessage<Block::GetStatsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_GetStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Block::SetTransactionHeaderFor::GetStatsResponse(const ::fidl::DecodedMessage<Block::GetStatsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_GetStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Block::SetTransactionHeaderFor::GetFifoRequest(const ::fidl::DecodedMessage<Block::GetFifoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_GetFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Block::SetTransactionHeaderFor::GetFifoResponse(const ::fidl::DecodedMessage<Block::GetFifoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_GetFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Block::SetTransactionHeaderFor::AttachVmoRequest(const ::fidl::DecodedMessage<Block::AttachVmoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_AttachVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Block::SetTransactionHeaderFor::AttachVmoResponse(const ::fidl::DecodedMessage<Block::AttachVmoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_AttachVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Block::SetTransactionHeaderFor::CloseFifoRequest(const ::fidl::DecodedMessage<Block::CloseFifoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_CloseFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Block::SetTransactionHeaderFor::CloseFifoResponse(const ::fidl::DecodedMessage<Block::CloseFifoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_CloseFifo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Block::SetTransactionHeaderFor::RebindDeviceRequest(const ::fidl::DecodedMessage<Block::RebindDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_RebindDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Block::SetTransactionHeaderFor::RebindDeviceResponse(const ::fidl::DecodedMessage<Block::RebindDeviceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBlock_RebindDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace block
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-block/gen/llcpp/include/fuchsia/hardware/block/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-block/gen/llcpp/include/fuchsia/hardware/block/llcpp/fidl.h
new file mode 100644
index 0000000..d2df2f7
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-block/gen/llcpp/include/fuchsia/hardware/block/llcpp/fidl.h
@@ -0,0 +1,1012 @@
+// 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/storage/metrics/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace block {
+
+struct BlockStats;
+struct VmoID;
+class Ftl;
+class Block;
+struct BlockInfo;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockStatsTable;
+
+struct BlockStats {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_BlockStatsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 480;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::storage::metrics::CallStat read = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat write = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat trim = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat flush = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat barrier_before = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat barrier_after = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_VmoIDTable;
+
+struct VmoID {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_VmoIDTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 2;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint16_t id = {};
+};
+
+constexpr uint16_t VMOID_INVALID = 0u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_FtlFormatRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_FtlFormatResponseTable;
+
+class Ftl final {
+ Ftl() = delete;
+ public:
+
+ struct FormatResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_FtlFormatResponseTable;
+ 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 FormatRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Format_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Format_Impl(::zx::unowned_channel _client_end);
+ ~Format_Impl() = default;
+ Format_Impl(Format_Impl&& other) = default;
+ Format_Impl& operator=(Format_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 Format = Format_Impl<FormatResponse>;
+ };
+
+ // 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 Format_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Format_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Format_Impl() = default;
+ Format_Impl(Format_Impl&& other) = default;
+ Format_Impl& operator=(Format_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 Format = Format_Impl<FormatResponse>;
+ };
+
+ 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 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Format Format();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Format Format(::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 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Format Format(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Format Format(::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<FormatResponse> Format(::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 = Ftl;
+ using _Base = ::fidl::CompleterBase;
+
+ class FormatCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<FormatResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using FormatCompleter = ::fidl::Completer<FormatCompleterBase>;
+
+ virtual void Format(FormatCompleter::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 FormatRequest(const ::fidl::DecodedMessage<Ftl::FormatRequest>& _msg);
+ static void FormatResponse(const ::fidl::DecodedMessage<Ftl::FormatResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetStatsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockGetFifoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockAttachVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockAttachVmoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockCloseFifoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockCloseFifoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockRebindDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockRebindDeviceResponseTable;
+
+class Block final {
+ Block() = 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_BlockGetInfoResponseTable;
+ 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_BlockGetStatsResponseTable;
+ 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_BlockGetStatsRequestTable;
+ 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_BlockGetFifoResponseTable;
+ 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_BlockAttachVmoResponseTable;
+ 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_BlockAttachVmoRequestTable;
+ 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_BlockCloseFifoResponseTable;
+ 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_BlockRebindDeviceResponseTable;
+ 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;
+
+
+ // 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*;
+ };
+
+ 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>;
+ };
+
+ // 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*;
+ };
+
+ 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>;
+ };
+
+ 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);
+
+ 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);
+
+ };
+
+ // 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);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Block;
+ 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;
+
+ };
+
+ // 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<Block::GetInfoRequest>& _msg);
+ static void GetInfoResponse(const ::fidl::DecodedMessage<Block::GetInfoResponse>& _msg);
+ static void GetStatsRequest(const ::fidl::DecodedMessage<Block::GetStatsRequest>& _msg);
+ static void GetStatsResponse(const ::fidl::DecodedMessage<Block::GetStatsResponse>& _msg);
+ static void GetFifoRequest(const ::fidl::DecodedMessage<Block::GetFifoRequest>& _msg);
+ static void GetFifoResponse(const ::fidl::DecodedMessage<Block::GetFifoResponse>& _msg);
+ static void AttachVmoRequest(const ::fidl::DecodedMessage<Block::AttachVmoRequest>& _msg);
+ static void AttachVmoResponse(const ::fidl::DecodedMessage<Block::AttachVmoResponse>& _msg);
+ static void CloseFifoRequest(const ::fidl::DecodedMessage<Block::CloseFifoRequest>& _msg);
+ static void CloseFifoResponse(const ::fidl::DecodedMessage<Block::CloseFifoResponse>& _msg);
+ static void RebindDeviceRequest(const ::fidl::DecodedMessage<Block::RebindDeviceRequest>& _msg);
+ static void RebindDeviceResponse(const ::fidl::DecodedMessage<Block::RebindDeviceResponse>& _msg);
+ };
+};
+
+constexpr uint32_t MAX_TRANSFER_UNBOUNDED = 4294967295u;
+
+constexpr uint32_t FLAG_TRIM_SUPPORT = 8u;
+
+constexpr uint32_t FLAG_REMOVABLE = 2u;
+
+constexpr uint32_t FLAG_READONLY = 1u;
+
+constexpr uint32_t FLAG_BOOTPART = 4u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_block_BlockInfoTable;
+
+struct BlockInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_block_BlockInfoTable;
+ 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 block_count = {};
+
+ uint32_t block_size = {};
+
+ uint32_t max_transfer_size = {};
+
+ uint32_t flags = {};
+
+ uint32_t reserved = {};
+};
+
+} // namespace block
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::BlockStats> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::block::BlockStats>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockStats, read) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockStats, write) == 80);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockStats, trim) == 160);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockStats, flush) == 240);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockStats, barrier_before) == 320);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockStats, barrier_after) == 400);
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::BlockStats) == ::llcpp::fuchsia::hardware::block::BlockStats::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::VmoID> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::block::VmoID>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::VmoID, id) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::VmoID) == ::llcpp::fuchsia::hardware::block::VmoID::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Ftl::FormatResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Ftl::FormatResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Ftl::FormatResponse)
+ == ::llcpp::fuchsia::hardware::block::Ftl::FormatResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Ftl::FormatResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Block::GetInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Block::GetInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Block::GetInfoResponse)
+ == ::llcpp::fuchsia::hardware::block::Block::GetInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::GetInfoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::GetInfoResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Block::GetStatsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Block::GetStatsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Block::GetStatsRequest)
+ == ::llcpp::fuchsia::hardware::block::Block::GetStatsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::GetStatsRequest, clear) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Block::GetStatsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Block::GetStatsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Block::GetStatsResponse)
+ == ::llcpp::fuchsia::hardware::block::Block::GetStatsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::GetStatsResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::GetStatsResponse, stats) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Block::GetFifoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Block::GetFifoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Block::GetFifoResponse)
+ == ::llcpp::fuchsia::hardware::block::Block::GetFifoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::GetFifoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::GetFifoResponse, fifo) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Block::AttachVmoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Block::AttachVmoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Block::AttachVmoRequest)
+ == ::llcpp::fuchsia::hardware::block::Block::AttachVmoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::AttachVmoRequest, vmo) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Block::AttachVmoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Block::AttachVmoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Block::AttachVmoResponse)
+ == ::llcpp::fuchsia::hardware::block::Block::AttachVmoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::AttachVmoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::AttachVmoResponse, vmoid) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Block::CloseFifoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Block::CloseFifoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Block::CloseFifoResponse)
+ == ::llcpp::fuchsia::hardware::block::Block::CloseFifoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::CloseFifoResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::Block::RebindDeviceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::block::Block::RebindDeviceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::Block::RebindDeviceResponse)
+ == ::llcpp::fuchsia::hardware::block::Block::RebindDeviceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::Block::RebindDeviceResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::block::BlockInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::block::BlockInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockInfo, block_count) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockInfo, block_size) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockInfo, max_transfer_size) == 12);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockInfo, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::block::BlockInfo, reserved) == 20);
+static_assert(sizeof(::llcpp::fuchsia::hardware::block::BlockInfo) == ::llcpp::fuchsia::hardware::block::BlockInfo::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-cpu-ctrl/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-cpu-ctrl/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..00eb29f
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-cpu-ctrl/gen/llcpp/fidl.cc
@@ -0,0 +1,458 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/cpu/ctrl/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace cpu {
+namespace ctrl {
+
+void ::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Device_GetPerformanceStateInfo_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Device_GetPerformanceStateInfo_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Device_GetPerformanceStateInfo_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetPerformanceStateInfo_Ordinal = 0x71d641d000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetPerformanceStateInfo_GenOrdinal = 0x2b34810b1fd3416elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetPerformanceStateInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetPerformanceStateInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetNumLogicalCores_Ordinal = 0x1d5aec6800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetNumLogicalCores_GenOrdinal = 0x74e304c90ca165c5lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetNumLogicalCoresRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetNumLogicalCoresResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetLogicalCoreId_Ordinal = 0x458d073700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetLogicalCoreId_GenOrdinal = 0x7168f98ddbd26058lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetLogicalCoreIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetLogicalCoreIdResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetPerformanceStateInfo_Impl<Device::GetPerformanceStateInfoResponse>::GetPerformanceStateInfo_Impl(::zx::unowned_channel _client_end, uint32_t state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPerformanceStateInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPerformanceStateInfoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetPerformanceStateInfoRequest*>(_write_bytes);
+ _request.state = std::move(state);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPerformanceStateInfoRequest));
+ ::fidl::DecodedMessage<GetPerformanceStateInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetPerformanceStateInfo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetPerformanceStateInfo Device::SyncClient::GetPerformanceStateInfo(uint32_t state) {
+ return ResultOf::GetPerformanceStateInfo(::zx::unowned_channel(this->channel_), std::move(state));
+}
+
+Device::ResultOf::GetPerformanceStateInfo Device::Call::GetPerformanceStateInfo(::zx::unowned_channel _client_end, uint32_t state) {
+ return ResultOf::GetPerformanceStateInfo(std::move(_client_end), std::move(state));
+}
+
+template <>
+Device::UnownedResultOf::GetPerformanceStateInfo_Impl<Device::GetPerformanceStateInfoResponse>::GetPerformanceStateInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t state, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetPerformanceStateInfoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetPerformanceStateInfoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetPerformanceStateInfoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetPerformanceStateInfoRequest*>(_request_buffer.data());
+ _request.state = std::move(state);
+ _request_buffer.set_actual(sizeof(GetPerformanceStateInfoRequest));
+ ::fidl::DecodedMessage<GetPerformanceStateInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetPerformanceStateInfo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetPerformanceStateInfo Device::SyncClient::GetPerformanceStateInfo(::fidl::BytePart _request_buffer, uint32_t state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPerformanceStateInfo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetPerformanceStateInfo Device::Call::GetPerformanceStateInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t state, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPerformanceStateInfo(std::move(_client_end), std::move(_request_buffer), std::move(state), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetPerformanceStateInfoResponse> Device::InPlace::GetPerformanceStateInfo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetPerformanceStateInfoRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetPerformanceStateInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetPerformanceStateInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPerformanceStateInfoRequest, GetPerformanceStateInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetPerformanceStateInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetNumLogicalCores_Impl<Device::GetNumLogicalCoresResponse>::GetNumLogicalCores_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNumLogicalCoresRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNumLogicalCoresRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNumLogicalCoresRequest));
+ ::fidl::DecodedMessage<GetNumLogicalCoresRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetNumLogicalCores(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetNumLogicalCores Device::SyncClient::GetNumLogicalCores() {
+ return ResultOf::GetNumLogicalCores(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetNumLogicalCores Device::Call::GetNumLogicalCores(::zx::unowned_channel _client_end) {
+ return ResultOf::GetNumLogicalCores(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetNumLogicalCores_Impl<Device::GetNumLogicalCoresResponse>::GetNumLogicalCores_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNumLogicalCoresRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetNumLogicalCoresRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetNumLogicalCoresRequest));
+ ::fidl::DecodedMessage<GetNumLogicalCoresRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetNumLogicalCores(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetNumLogicalCores Device::SyncClient::GetNumLogicalCores(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNumLogicalCores(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetNumLogicalCores Device::Call::GetNumLogicalCores(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNumLogicalCores(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetNumLogicalCoresResponse> Device::InPlace::GetNumLogicalCores(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetNumLogicalCoresRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetNumLogicalCoresRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetNumLogicalCoresRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetNumLogicalCoresResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNumLogicalCoresRequest, GetNumLogicalCoresResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetNumLogicalCoresResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetLogicalCoreId_Impl<Device::GetLogicalCoreIdResponse>::GetLogicalCoreId_Impl(::zx::unowned_channel _client_end, uint64_t index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetLogicalCoreIdRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetLogicalCoreIdRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetLogicalCoreIdRequest*>(_write_bytes);
+ _request.index = std::move(index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetLogicalCoreIdRequest));
+ ::fidl::DecodedMessage<GetLogicalCoreIdRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetLogicalCoreId(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetLogicalCoreId Device::SyncClient::GetLogicalCoreId(uint64_t index) {
+ return ResultOf::GetLogicalCoreId(::zx::unowned_channel(this->channel_), std::move(index));
+}
+
+Device::ResultOf::GetLogicalCoreId Device::Call::GetLogicalCoreId(::zx::unowned_channel _client_end, uint64_t index) {
+ return ResultOf::GetLogicalCoreId(std::move(_client_end), std::move(index));
+}
+
+template <>
+Device::UnownedResultOf::GetLogicalCoreId_Impl<Device::GetLogicalCoreIdResponse>::GetLogicalCoreId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t index, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetLogicalCoreIdRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetLogicalCoreIdResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetLogicalCoreIdRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetLogicalCoreIdRequest*>(_request_buffer.data());
+ _request.index = std::move(index);
+ _request_buffer.set_actual(sizeof(GetLogicalCoreIdRequest));
+ ::fidl::DecodedMessage<GetLogicalCoreIdRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetLogicalCoreId(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetLogicalCoreId Device::SyncClient::GetLogicalCoreId(::fidl::BytePart _request_buffer, uint64_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetLogicalCoreId(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(index), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetLogicalCoreId Device::Call::GetLogicalCoreId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetLogicalCoreId(std::move(_client_end), std::move(_request_buffer), std::move(index), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetLogicalCoreIdResponse> Device::InPlace::GetLogicalCoreId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetLogicalCoreIdRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetLogicalCoreIdRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetLogicalCoreIdResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetLogicalCoreIdRequest, GetLogicalCoreIdResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetLogicalCoreIdResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetPerformanceStateInfo_Ordinal:
+ case kDevice_GetPerformanceStateInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPerformanceStateInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetPerformanceStateInfo(std::move(message->state),
+ Interface::GetPerformanceStateInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetNumLogicalCores_Ordinal:
+ case kDevice_GetNumLogicalCores_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNumLogicalCoresRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetNumLogicalCores(
+ Interface::GetNumLogicalCoresCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetLogicalCoreId_Ordinal:
+ case kDevice_GetLogicalCoreId_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetLogicalCoreIdRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetLogicalCoreId(std::move(message->index),
+ Interface::GetLogicalCoreIdCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetPerformanceStateInfoCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPerformanceStateInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetPerformanceStateInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetPerformanceStateInfoResponse(
+ ::fidl::DecodedMessage<GetPerformanceStateInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPerformanceStateInfoResponse::PrimarySize,
+ GetPerformanceStateInfoResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::GetPerformanceStateInfoCompleterBase::ReplySuccess(::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo info) {
+ Device_GetPerformanceStateInfo_Response response;
+ response.info = std::move(info);
+
+ Reply(Device_GetPerformanceStateInfo_Result::WithResponse(&response));
+}
+void Device::Interface::GetPerformanceStateInfoCompleterBase::ReplyError(int32_t error) {
+ Reply(Device_GetPerformanceStateInfo_Result::WithErr(&error));
+}
+
+void Device::Interface::GetPerformanceStateInfoCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Result result) {
+ if (_buffer.capacity() < GetPerformanceStateInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPerformanceStateInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetPerformanceStateInfoResponse(
+ ::fidl::DecodedMessage<GetPerformanceStateInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPerformanceStateInfoResponse::PrimarySize,
+ GetPerformanceStateInfoResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::GetPerformanceStateInfoCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo info) {
+ Device_GetPerformanceStateInfo_Response response;
+ response.info = std::move(info);
+
+ Reply(std::move(_buffer), Device_GetPerformanceStateInfo_Result::WithResponse(&response));
+}
+
+void Device::Interface::GetPerformanceStateInfoCompleterBase::Reply(::fidl::DecodedMessage<GetPerformanceStateInfoResponse> params) {
+ Device::SetTransactionHeaderFor::GetPerformanceStateInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetNumLogicalCoresCompleterBase::Reply(uint64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNumLogicalCoresResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetNumLogicalCoresResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetNumLogicalCoresResponse(
+ ::fidl::DecodedMessage<GetNumLogicalCoresResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNumLogicalCoresResponse::PrimarySize,
+ GetNumLogicalCoresResponse::PrimarySize)));
+ _response.count = std::move(count);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNumLogicalCoresResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetNumLogicalCoresResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetNumLogicalCoresCompleterBase::Reply(::fidl::BytePart _buffer, uint64_t count) {
+ if (_buffer.capacity() < GetNumLogicalCoresResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetNumLogicalCoresResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetNumLogicalCoresResponse(
+ ::fidl::DecodedMessage<GetNumLogicalCoresResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNumLogicalCoresResponse::PrimarySize,
+ GetNumLogicalCoresResponse::PrimarySize)));
+ _response.count = std::move(count);
+ _buffer.set_actual(sizeof(GetNumLogicalCoresResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetNumLogicalCoresResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetNumLogicalCoresCompleterBase::Reply(::fidl::DecodedMessage<GetNumLogicalCoresResponse> params) {
+ Device::SetTransactionHeaderFor::GetNumLogicalCoresResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetLogicalCoreIdCompleterBase::Reply(uint64_t id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetLogicalCoreIdResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetLogicalCoreIdResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetLogicalCoreIdResponse(
+ ::fidl::DecodedMessage<GetLogicalCoreIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetLogicalCoreIdResponse::PrimarySize,
+ GetLogicalCoreIdResponse::PrimarySize)));
+ _response.id = std::move(id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetLogicalCoreIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetLogicalCoreIdResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetLogicalCoreIdCompleterBase::Reply(::fidl::BytePart _buffer, uint64_t id) {
+ if (_buffer.capacity() < GetLogicalCoreIdResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetLogicalCoreIdResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetLogicalCoreIdResponse(
+ ::fidl::DecodedMessage<GetLogicalCoreIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetLogicalCoreIdResponse::PrimarySize,
+ GetLogicalCoreIdResponse::PrimarySize)));
+ _response.id = std::move(id);
+ _buffer.set_actual(sizeof(GetLogicalCoreIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetLogicalCoreIdResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetLogicalCoreIdCompleterBase::Reply(::fidl::DecodedMessage<GetLogicalCoreIdResponse> params) {
+ Device::SetTransactionHeaderFor::GetLogicalCoreIdResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetPerformanceStateInfoRequest(const ::fidl::DecodedMessage<Device::GetPerformanceStateInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetPerformanceStateInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetPerformanceStateInfoResponse(const ::fidl::DecodedMessage<Device::GetPerformanceStateInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetPerformanceStateInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetNumLogicalCoresRequest(const ::fidl::DecodedMessage<Device::GetNumLogicalCoresRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetNumLogicalCores_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetNumLogicalCoresResponse(const ::fidl::DecodedMessage<Device::GetNumLogicalCoresResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetNumLogicalCores_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetLogicalCoreIdRequest(const ::fidl::DecodedMessage<Device::GetLogicalCoreIdRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetLogicalCoreId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetLogicalCoreIdResponse(const ::fidl::DecodedMessage<Device::GetLogicalCoreIdResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetLogicalCoreId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace ctrl
+} // namespace cpu
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-cpu-ctrl/gen/llcpp/include/fuchsia/hardware/cpu/ctrl/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-cpu-ctrl/gen/llcpp/include/fuchsia/hardware/cpu/ctrl/llcpp/fidl.h
new file mode 100644
index 0000000..abc6b37
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-cpu-ctrl/gen/llcpp/include/fuchsia/hardware/cpu/ctrl/llcpp/fidl.h
@@ -0,0 +1,628 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace cpu {
+namespace ctrl {
+
+struct CpuPerformanceStateInfo;
+struct Device_GetPerformanceStateInfo_Response;
+struct Device_GetPerformanceStateInfo_Result;
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_Device_GetPerformanceStateInfo_ResultTable;
+
+struct Device_GetPerformanceStateInfo_Result {
+ Device_GetPerformanceStateInfo_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Device_GetPerformanceStateInfo_Result WithResponse(::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response* val) {
+ Device_GetPerformanceStateInfo_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Device_GetPerformanceStateInfo_Result WithErr(int32_t* val) {
+ Device_GetPerformanceStateInfo_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_ctrl_Device_GetPerformanceStateInfo_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+constexpr int64_t VOLTAGE_UNKNOWN = -1;
+
+// CpuPerformanceStateInfo::frequency_hz and CpuPerformanceStateInfo::voltage_uv
+// are set to this if the frequency and voltage for the given performance state
+// are unknown respectively.
+constexpr int64_t FREQUENCY_UNKNOWN = -1;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_CpuPerformanceStateInfoTable;
+
+// A collection of some basic information for a given performance state.
+struct CpuPerformanceStateInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_ctrl_CpuPerformanceStateInfoTable;
+ 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;
+
+ // Frequency the core is operating at in hertz.
+ int64_t frequency_hz = {};
+
+ int64_t voltage_uv = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_Device_GetPerformanceStateInfo_ResponseTable;
+
+struct Device_GetPerformanceStateInfo_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_ctrl_Device_GetPerformanceStateInfo_ResponseTable;
+ 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;
+
+ ::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo info = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetPerformanceStateInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetPerformanceStateInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetNumLogicalCoresRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetNumLogicalCoresResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetLogicalCoreIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_ctrl_DeviceGetLogicalCoreIdResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetPerformanceStateInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_ctrl_DeviceGetPerformanceStateInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetPerformanceStateInfoRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_ctrl_DeviceGetPerformanceStateInfoRequestTable;
+ 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 = GetPerformanceStateInfoResponse;
+ };
+
+ struct GetNumLogicalCoresResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_ctrl_DeviceGetNumLogicalCoresResponseTable;
+ 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 GetNumLogicalCoresRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetLogicalCoreIdResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_ctrl_DeviceGetLogicalCoreIdResponseTable;
+ 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 GetLogicalCoreIdRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_ctrl_DeviceGetLogicalCoreIdRequestTable;
+ 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 = GetLogicalCoreIdResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetPerformanceStateInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetPerformanceStateInfo_Impl(::zx::unowned_channel _client_end, uint32_t state);
+ ~GetPerformanceStateInfo_Impl() = default;
+ GetPerformanceStateInfo_Impl(GetPerformanceStateInfo_Impl&& other) = default;
+ GetPerformanceStateInfo_Impl& operator=(GetPerformanceStateInfo_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 GetNumLogicalCores_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetNumLogicalCores_Impl(::zx::unowned_channel _client_end);
+ ~GetNumLogicalCores_Impl() = default;
+ GetNumLogicalCores_Impl(GetNumLogicalCores_Impl&& other) = default;
+ GetNumLogicalCores_Impl& operator=(GetNumLogicalCores_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 GetLogicalCoreId_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetLogicalCoreId_Impl(::zx::unowned_channel _client_end, uint64_t index);
+ ~GetLogicalCoreId_Impl() = default;
+ GetLogicalCoreId_Impl(GetLogicalCoreId_Impl&& other) = default;
+ GetLogicalCoreId_Impl& operator=(GetLogicalCoreId_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 GetPerformanceStateInfo = GetPerformanceStateInfo_Impl<GetPerformanceStateInfoResponse>;
+ using GetNumLogicalCores = GetNumLogicalCores_Impl<GetNumLogicalCoresResponse>;
+ using GetLogicalCoreId = GetLogicalCoreId_Impl<GetLogicalCoreIdResponse>;
+ };
+
+ // 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 GetPerformanceStateInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetPerformanceStateInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t state, ::fidl::BytePart _response_buffer);
+ ~GetPerformanceStateInfo_Impl() = default;
+ GetPerformanceStateInfo_Impl(GetPerformanceStateInfo_Impl&& other) = default;
+ GetPerformanceStateInfo_Impl& operator=(GetPerformanceStateInfo_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 GetNumLogicalCores_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetNumLogicalCores_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetNumLogicalCores_Impl() = default;
+ GetNumLogicalCores_Impl(GetNumLogicalCores_Impl&& other) = default;
+ GetNumLogicalCores_Impl& operator=(GetNumLogicalCores_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 GetLogicalCoreId_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetLogicalCoreId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t index, ::fidl::BytePart _response_buffer);
+ ~GetLogicalCoreId_Impl() = default;
+ GetLogicalCoreId_Impl(GetLogicalCoreId_Impl&& other) = default;
+ GetLogicalCoreId_Impl& operator=(GetLogicalCoreId_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 GetPerformanceStateInfo = GetPerformanceStateInfo_Impl<GetPerformanceStateInfoResponse>;
+ using GetNumLogicalCores = GetNumLogicalCores_Impl<GetNumLogicalCoresResponse>;
+ using GetLogicalCoreId = GetLogicalCoreId_Impl<GetLogicalCoreIdResponse>;
+ };
+
+ 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_; }
+
+ // Returns information about a given performance state for this performance
+ // domain.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetPerformanceStateInfo GetPerformanceStateInfo(uint32_t state);
+
+ // Returns information about a given performance state for this performance
+ // domain.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetPerformanceStateInfo GetPerformanceStateInfo(::fidl::BytePart _request_buffer, uint32_t state, ::fidl::BytePart _response_buffer);
+
+ // Returns the number of logical cores contained within this performance
+ // domain.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetNumLogicalCores GetNumLogicalCores();
+
+ // Returns the number of logical cores contained within this performance
+ // domain.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetNumLogicalCores GetNumLogicalCores(::fidl::BytePart _response_buffer);
+
+ // Returns a global system-wide core ID for the nth core in this
+ // performance domain. `index` must be a value in the range [0, n) where
+ // n is the value returned by GetNumLogicalCores().
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetLogicalCoreId GetLogicalCoreId(uint64_t index);
+
+ // Returns a global system-wide core ID for the nth core in this
+ // performance domain. `index` must be a value in the range [0, n) where
+ // n is the value returned by GetNumLogicalCores().
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetLogicalCoreId GetLogicalCoreId(::fidl::BytePart _request_buffer, uint64_t index, ::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:
+
+ // Returns information about a given performance state for this performance
+ // domain.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetPerformanceStateInfo GetPerformanceStateInfo(::zx::unowned_channel _client_end, uint32_t state);
+
+ // Returns information about a given performance state for this performance
+ // domain.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetPerformanceStateInfo GetPerformanceStateInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t state, ::fidl::BytePart _response_buffer);
+
+ // Returns the number of logical cores contained within this performance
+ // domain.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetNumLogicalCores GetNumLogicalCores(::zx::unowned_channel _client_end);
+
+ // Returns the number of logical cores contained within this performance
+ // domain.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetNumLogicalCores GetNumLogicalCores(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns a global system-wide core ID for the nth core in this
+ // performance domain. `index` must be a value in the range [0, n) where
+ // n is the value returned by GetNumLogicalCores().
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetLogicalCoreId GetLogicalCoreId(::zx::unowned_channel _client_end, uint64_t index);
+
+ // Returns a global system-wide core ID for the nth core in this
+ // performance domain. `index` must be a value in the range [0, n) where
+ // n is the value returned by GetNumLogicalCores().
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetLogicalCoreId GetLogicalCoreId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t index, ::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:
+
+ // Returns information about a given performance state for this performance
+ // domain.
+ static ::fidl::DecodeResult<GetPerformanceStateInfoResponse> GetPerformanceStateInfo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetPerformanceStateInfoRequest> params, ::fidl::BytePart response_buffer);
+
+ // Returns the number of logical cores contained within this performance
+ // domain.
+ static ::fidl::DecodeResult<GetNumLogicalCoresResponse> GetNumLogicalCores(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns a global system-wide core ID for the nth core in this
+ // performance domain. `index` must be a value in the range [0, n) where
+ // n is the value returned by GetNumLogicalCores().
+ static ::fidl::DecodeResult<GetLogicalCoreIdResponse> GetLogicalCoreId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetLogicalCoreIdRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetPerformanceStateInfoCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Result result);
+ void ReplySuccess(::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo info);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo info);
+ void Reply(::fidl::DecodedMessage<GetPerformanceStateInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPerformanceStateInfoCompleter = ::fidl::Completer<GetPerformanceStateInfoCompleterBase>;
+
+ virtual void GetPerformanceStateInfo(uint32_t state, GetPerformanceStateInfoCompleter::Sync _completer) = 0;
+
+ class GetNumLogicalCoresCompleterBase : public _Base {
+ public:
+ void Reply(uint64_t count);
+ void Reply(::fidl::BytePart _buffer, uint64_t count);
+ void Reply(::fidl::DecodedMessage<GetNumLogicalCoresResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetNumLogicalCoresCompleter = ::fidl::Completer<GetNumLogicalCoresCompleterBase>;
+
+ virtual void GetNumLogicalCores(GetNumLogicalCoresCompleter::Sync _completer) = 0;
+
+ class GetLogicalCoreIdCompleterBase : public _Base {
+ public:
+ void Reply(uint64_t id);
+ void Reply(::fidl::BytePart _buffer, uint64_t id);
+ void Reply(::fidl::DecodedMessage<GetLogicalCoreIdResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetLogicalCoreIdCompleter = ::fidl::Completer<GetLogicalCoreIdCompleterBase>;
+
+ virtual void GetLogicalCoreId(uint64_t index, GetLogicalCoreIdCompleter::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 GetPerformanceStateInfoRequest(const ::fidl::DecodedMessage<Device::GetPerformanceStateInfoRequest>& _msg);
+ static void GetPerformanceStateInfoResponse(const ::fidl::DecodedMessage<Device::GetPerformanceStateInfoResponse>& _msg);
+ static void GetNumLogicalCoresRequest(const ::fidl::DecodedMessage<Device::GetNumLogicalCoresRequest>& _msg);
+ static void GetNumLogicalCoresResponse(const ::fidl::DecodedMessage<Device::GetNumLogicalCoresResponse>& _msg);
+ static void GetLogicalCoreIdRequest(const ::fidl::DecodedMessage<Device::GetLogicalCoreIdRequest>& _msg);
+ static void GetLogicalCoreIdResponse(const ::fidl::DecodedMessage<Device::GetLogicalCoreIdResponse>& _msg);
+ };
+};
+
+} // namespace ctrl
+} // namespace cpu
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo, frequency_hz) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo, voltage_uv) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo) == ::llcpp::fuchsia::hardware::cpu::ctrl::CpuPerformanceStateInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response, info) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response) == ::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::ctrl::Device_GetPerformanceStateInfo_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoRequest)
+ == ::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoRequest, state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoResponse)
+ == ::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetPerformanceStateInfoResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetNumLogicalCoresResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetNumLogicalCoresResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetNumLogicalCoresResponse)
+ == ::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetNumLogicalCoresResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetNumLogicalCoresResponse, count) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdRequest)
+ == ::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdRequest, index) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdResponse)
+ == ::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::ctrl::Device::GetLogicalCoreIdResponse, id) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-cpu-insntrace/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-cpu-insntrace/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..0ffc994
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-cpu-insntrace/gen/llcpp/fidl.cc
@@ -0,0 +1,1627 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/cpu/insntrace/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace cpu {
+namespace insntrace {
+
+void ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_Terminate_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_Terminate_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_Terminate_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_ReleaseThreadBuffer_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_ReleaseThreadBuffer_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_ReleaseThreadBuffer_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_Initialize_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_Initialize_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_Initialize_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_AssignThreadBuffer_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_AssignThreadBuffer_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_AssignThreadBuffer_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_AllocateBuffer_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_AllocateBuffer_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_AllocateBuffer_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kController_Initialize_Ordinal = 0x59b0d03400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Initialize_GenOrdinal = 0x1ca155857f30468lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerInitializeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerInitializeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Terminate_Ordinal = 0x720fc32b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Terminate_GenOrdinal = 0x6115092acef4d497lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerTerminateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerTerminateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetAllocation_Ordinal = 0x1226c5d000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetAllocation_GenOrdinal = 0xabef26cf562354flu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetAllocationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetAllocationResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_AllocateBuffer_Ordinal = 0x6e2611dd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_AllocateBuffer_GenOrdinal = 0x5a0c3fcdcca20055lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerAllocateBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerAllocateBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_AssignThreadBuffer_Ordinal = 0x39f7e62f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_AssignThreadBuffer_GenOrdinal = 0x5d699c2d22aafef2lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerAssignThreadBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerAssignThreadBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseThreadBuffer_Ordinal = 0x50b6cf000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseThreadBuffer_GenOrdinal = 0x5dd0a7fe5a69bb8lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerReleaseThreadBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerReleaseThreadBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetBufferConfig_Ordinal = 0x283603b800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetBufferConfig_GenOrdinal = 0x3e2bb907fc1c195dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetBufferState_Ordinal = 0x1ae1ae5f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetBufferState_GenOrdinal = 0x6069af45b952f39flu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferStateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetChunkHandle_Ordinal = 0x27fbff0900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetChunkHandle_GenOrdinal = 0x11b8b37d81869ea4lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetChunkHandleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetChunkHandleResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_FreeBuffer_Ordinal = 0x3f86f0d000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_FreeBuffer_GenOrdinal = 0x6909636959de71c7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerFreeBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerFreeBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Start_Ordinal = 0x58e0bb6900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Start_GenOrdinal = 0x3c92516dbfd4d43blu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerStartResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Stop_Ordinal = 0x1cb723ab00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Stop_GenOrdinal = 0x7e33aef68733c1fclu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerStopResponseTable;
+
+} // namespace
+template <>
+Controller::ResultOf::Initialize_Impl<Controller::InitializeResponse>::Initialize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InitializeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, InitializeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<InitializeRequest*>(_write_bytes);
+ _request.allocation = std::move(allocation);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(InitializeRequest));
+ ::fidl::DecodedMessage<InitializeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Initialize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::Initialize Controller::SyncClient::Initialize(::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation) {
+ return ResultOf::Initialize(::zx::unowned_channel(this->channel_), std::move(allocation));
+}
+
+Controller::ResultOf::Initialize Controller::Call::Initialize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation) {
+ return ResultOf::Initialize(std::move(_client_end), std::move(allocation));
+}
+
+template <>
+Controller::UnownedResultOf::Initialize_Impl<Controller::InitializeResponse>::Initialize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < InitializeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<InitializeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, InitializeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<InitializeRequest*>(_request_buffer.data());
+ _request.allocation = std::move(allocation);
+ _request_buffer.set_actual(sizeof(InitializeRequest));
+ ::fidl::DecodedMessage<InitializeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::Initialize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::Initialize Controller::SyncClient::Initialize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Initialize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(allocation), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::Initialize Controller::Call::Initialize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Initialize(std::move(_client_end), std::move(_request_buffer), std::move(allocation), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::InitializeResponse> Controller::InPlace::Initialize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<InitializeRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::InitializeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::InitializeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<InitializeRequest, InitializeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::InitializeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Terminate_Impl<Controller::TerminateResponse>::Terminate_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TerminateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, TerminateRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(TerminateRequest));
+ ::fidl::DecodedMessage<TerminateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Terminate(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::Terminate Controller::SyncClient::Terminate() {
+ return ResultOf::Terminate(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::Terminate Controller::Call::Terminate(::zx::unowned_channel _client_end) {
+ return ResultOf::Terminate(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::Terminate_Impl<Controller::TerminateResponse>::Terminate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(TerminateRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, TerminateRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(TerminateRequest));
+ ::fidl::DecodedMessage<TerminateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::Terminate(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::Terminate Controller::SyncClient::Terminate(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Terminate(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::Terminate Controller::Call::Terminate(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Terminate(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::TerminateResponse> Controller::InPlace::Terminate(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(TerminateRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<TerminateRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::TerminateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::TerminateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<TerminateRequest, TerminateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::TerminateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetAllocation_Impl<Controller::GetAllocationResponse>::GetAllocation_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAllocationRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAllocationRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAllocationRequest));
+ ::fidl::DecodedMessage<GetAllocationRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetAllocation(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetAllocation Controller::SyncClient::GetAllocation() {
+ return ResultOf::GetAllocation(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetAllocation Controller::Call::GetAllocation(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAllocation(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetAllocation_Impl<Controller::GetAllocationResponse>::GetAllocation_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAllocationRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAllocationRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAllocationRequest));
+ ::fidl::DecodedMessage<GetAllocationRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetAllocation(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetAllocation Controller::SyncClient::GetAllocation(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAllocation(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetAllocation Controller::Call::GetAllocation(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAllocation(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetAllocationResponse> Controller::InPlace::GetAllocation(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAllocationRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAllocationRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetAllocationRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetAllocationResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAllocationRequest, GetAllocationResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetAllocationResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::AllocateBuffer_Impl<Controller::AllocateBufferResponse>::AllocateBuffer_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocateBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AllocateBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateBufferRequest*>(_write_bytes);
+ _request.config = std::move(config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AllocateBufferRequest));
+ ::fidl::DecodedMessage<AllocateBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::AllocateBuffer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::AllocateBuffer Controller::SyncClient::AllocateBuffer(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config) {
+ return ResultOf::AllocateBuffer(::zx::unowned_channel(this->channel_), std::move(config));
+}
+
+Controller::ResultOf::AllocateBuffer Controller::Call::AllocateBuffer(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config) {
+ return ResultOf::AllocateBuffer(std::move(_client_end), std::move(config));
+}
+
+template <>
+Controller::UnownedResultOf::AllocateBuffer_Impl<Controller::AllocateBufferResponse>::AllocateBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AllocateBufferRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AllocateBufferResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AllocateBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateBufferRequest*>(_request_buffer.data());
+ _request.config = std::move(config);
+ _request_buffer.set_actual(sizeof(AllocateBufferRequest));
+ ::fidl::DecodedMessage<AllocateBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::AllocateBuffer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::AllocateBuffer Controller::SyncClient::AllocateBuffer(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AllocateBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::AllocateBuffer Controller::Call::AllocateBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AllocateBuffer(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::AllocateBufferResponse> Controller::InPlace::AllocateBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateBufferRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::AllocateBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::AllocateBufferResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AllocateBufferRequest, AllocateBufferResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::AllocateBufferResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::AssignThreadBuffer_Impl<Controller::AssignThreadBufferResponse>::AssignThreadBuffer_Impl(::zx::unowned_channel _client_end, uint32_t descriptor, ::zx::thread thread) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AssignThreadBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AssignThreadBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AssignThreadBufferRequest*>(_write_bytes);
+ _request.descriptor = std::move(descriptor);
+ _request.thread = std::move(thread);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AssignThreadBufferRequest));
+ ::fidl::DecodedMessage<AssignThreadBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::AssignThreadBuffer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::AssignThreadBuffer Controller::SyncClient::AssignThreadBuffer(uint32_t descriptor, ::zx::thread thread) {
+ return ResultOf::AssignThreadBuffer(::zx::unowned_channel(this->channel_), std::move(descriptor), std::move(thread));
+}
+
+Controller::ResultOf::AssignThreadBuffer Controller::Call::AssignThreadBuffer(::zx::unowned_channel _client_end, uint32_t descriptor, ::zx::thread thread) {
+ return ResultOf::AssignThreadBuffer(std::move(_client_end), std::move(descriptor), std::move(thread));
+}
+
+template <>
+Controller::UnownedResultOf::AssignThreadBuffer_Impl<Controller::AssignThreadBufferResponse>::AssignThreadBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AssignThreadBufferRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AssignThreadBufferResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AssignThreadBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AssignThreadBufferRequest*>(_request_buffer.data());
+ _request.descriptor = std::move(descriptor);
+ _request.thread = std::move(thread);
+ _request_buffer.set_actual(sizeof(AssignThreadBufferRequest));
+ ::fidl::DecodedMessage<AssignThreadBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::AssignThreadBuffer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::AssignThreadBuffer Controller::SyncClient::AssignThreadBuffer(::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AssignThreadBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(descriptor), std::move(thread), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::AssignThreadBuffer Controller::Call::AssignThreadBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AssignThreadBuffer(std::move(_client_end), std::move(_request_buffer), std::move(descriptor), std::move(thread), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::AssignThreadBufferResponse> Controller::InPlace::AssignThreadBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AssignThreadBufferRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::AssignThreadBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::AssignThreadBufferResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AssignThreadBufferRequest, AssignThreadBufferResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::AssignThreadBufferResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::ReleaseThreadBuffer_Impl<Controller::ReleaseThreadBufferResponse>::ReleaseThreadBuffer_Impl(::zx::unowned_channel _client_end, uint32_t descriptor, ::zx::thread thread) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseThreadBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReleaseThreadBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseThreadBufferRequest*>(_write_bytes);
+ _request.descriptor = std::move(descriptor);
+ _request.thread = std::move(thread);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReleaseThreadBufferRequest));
+ ::fidl::DecodedMessage<ReleaseThreadBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::ReleaseThreadBuffer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::ReleaseThreadBuffer Controller::SyncClient::ReleaseThreadBuffer(uint32_t descriptor, ::zx::thread thread) {
+ return ResultOf::ReleaseThreadBuffer(::zx::unowned_channel(this->channel_), std::move(descriptor), std::move(thread));
+}
+
+Controller::ResultOf::ReleaseThreadBuffer Controller::Call::ReleaseThreadBuffer(::zx::unowned_channel _client_end, uint32_t descriptor, ::zx::thread thread) {
+ return ResultOf::ReleaseThreadBuffer(std::move(_client_end), std::move(descriptor), std::move(thread));
+}
+
+template <>
+Controller::UnownedResultOf::ReleaseThreadBuffer_Impl<Controller::ReleaseThreadBufferResponse>::ReleaseThreadBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReleaseThreadBufferRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReleaseThreadBufferResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReleaseThreadBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseThreadBufferRequest*>(_request_buffer.data());
+ _request.descriptor = std::move(descriptor);
+ _request.thread = std::move(thread);
+ _request_buffer.set_actual(sizeof(ReleaseThreadBufferRequest));
+ ::fidl::DecodedMessage<ReleaseThreadBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::ReleaseThreadBuffer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::ReleaseThreadBuffer Controller::SyncClient::ReleaseThreadBuffer(::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReleaseThreadBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(descriptor), std::move(thread), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::ReleaseThreadBuffer Controller::Call::ReleaseThreadBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReleaseThreadBuffer(std::move(_client_end), std::move(_request_buffer), std::move(descriptor), std::move(thread), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ReleaseThreadBufferResponse> Controller::InPlace::ReleaseThreadBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseThreadBufferRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::ReleaseThreadBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ReleaseThreadBufferResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReleaseThreadBufferRequest, ReleaseThreadBufferResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ReleaseThreadBufferResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetBufferConfig_Impl<Controller::GetBufferConfigResponse>::GetBufferConfig_Impl(::zx::unowned_channel _client_end, uint32_t descriptor) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetBufferConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferConfigRequest*>(_write_bytes);
+ _request.descriptor = std::move(descriptor);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBufferConfigRequest));
+ ::fidl::DecodedMessage<GetBufferConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetBufferConfig(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetBufferConfig Controller::SyncClient::GetBufferConfig(uint32_t descriptor) {
+ return ResultOf::GetBufferConfig(::zx::unowned_channel(this->channel_), std::move(descriptor));
+}
+
+Controller::ResultOf::GetBufferConfig Controller::Call::GetBufferConfig(::zx::unowned_channel _client_end, uint32_t descriptor) {
+ return ResultOf::GetBufferConfig(std::move(_client_end), std::move(descriptor));
+}
+
+template <>
+Controller::UnownedResultOf::GetBufferConfig_Impl<Controller::GetBufferConfigResponse>::GetBufferConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetBufferConfigRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetBufferConfigResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetBufferConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferConfigRequest*>(_request_buffer.data());
+ _request.descriptor = std::move(descriptor);
+ _request_buffer.set_actual(sizeof(GetBufferConfigRequest));
+ ::fidl::DecodedMessage<GetBufferConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetBufferConfig(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetBufferConfig Controller::SyncClient::GetBufferConfig(::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBufferConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(descriptor), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetBufferConfig Controller::Call::GetBufferConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBufferConfig(std::move(_client_end), std::move(_request_buffer), std::move(descriptor), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetBufferConfigResponse> Controller::InPlace::GetBufferConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferConfigRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::GetBufferConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetBufferConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetBufferConfigRequest, GetBufferConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetBufferConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetBufferState_Impl<Controller::GetBufferStateResponse>::GetBufferState_Impl(::zx::unowned_channel _client_end, uint32_t descriptor) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferStateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetBufferStateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferStateRequest*>(_write_bytes);
+ _request.descriptor = std::move(descriptor);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBufferStateRequest));
+ ::fidl::DecodedMessage<GetBufferStateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetBufferState(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetBufferState Controller::SyncClient::GetBufferState(uint32_t descriptor) {
+ return ResultOf::GetBufferState(::zx::unowned_channel(this->channel_), std::move(descriptor));
+}
+
+Controller::ResultOf::GetBufferState Controller::Call::GetBufferState(::zx::unowned_channel _client_end, uint32_t descriptor) {
+ return ResultOf::GetBufferState(std::move(_client_end), std::move(descriptor));
+}
+
+template <>
+Controller::UnownedResultOf::GetBufferState_Impl<Controller::GetBufferStateResponse>::GetBufferState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetBufferStateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetBufferStateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetBufferStateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferStateRequest*>(_request_buffer.data());
+ _request.descriptor = std::move(descriptor);
+ _request_buffer.set_actual(sizeof(GetBufferStateRequest));
+ ::fidl::DecodedMessage<GetBufferStateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetBufferState(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetBufferState Controller::SyncClient::GetBufferState(::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBufferState(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(descriptor), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetBufferState Controller::Call::GetBufferState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBufferState(std::move(_client_end), std::move(_request_buffer), std::move(descriptor), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetBufferStateResponse> Controller::InPlace::GetBufferState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferStateRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::GetBufferStateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetBufferStateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetBufferStateRequest, GetBufferStateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetBufferStateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetChunkHandle_Impl<Controller::GetChunkHandleResponse>::GetChunkHandle_Impl(::zx::unowned_channel _client_end, uint32_t descriptor, uint32_t chunk_num) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChunkHandleRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetChunkHandleRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetChunkHandleRequest*>(_write_bytes);
+ _request.descriptor = std::move(descriptor);
+ _request.chunk_num = std::move(chunk_num);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChunkHandleRequest));
+ ::fidl::DecodedMessage<GetChunkHandleRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetChunkHandle(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetChunkHandle Controller::SyncClient::GetChunkHandle(uint32_t descriptor, uint32_t chunk_num) {
+ return ResultOf::GetChunkHandle(::zx::unowned_channel(this->channel_), std::move(descriptor), std::move(chunk_num));
+}
+
+Controller::ResultOf::GetChunkHandle Controller::Call::GetChunkHandle(::zx::unowned_channel _client_end, uint32_t descriptor, uint32_t chunk_num) {
+ return ResultOf::GetChunkHandle(std::move(_client_end), std::move(descriptor), std::move(chunk_num));
+}
+
+template <>
+Controller::UnownedResultOf::GetChunkHandle_Impl<Controller::GetChunkHandleResponse>::GetChunkHandle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, uint32_t chunk_num, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetChunkHandleRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetChunkHandleResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetChunkHandleRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetChunkHandleRequest*>(_request_buffer.data());
+ _request.descriptor = std::move(descriptor);
+ _request.chunk_num = std::move(chunk_num);
+ _request_buffer.set_actual(sizeof(GetChunkHandleRequest));
+ ::fidl::DecodedMessage<GetChunkHandleRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetChunkHandle(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetChunkHandle Controller::SyncClient::GetChunkHandle(::fidl::BytePart _request_buffer, uint32_t descriptor, uint32_t chunk_num, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetChunkHandle(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(descriptor), std::move(chunk_num), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetChunkHandle Controller::Call::GetChunkHandle(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, uint32_t chunk_num, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetChunkHandle(std::move(_client_end), std::move(_request_buffer), std::move(descriptor), std::move(chunk_num), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetChunkHandleResponse> Controller::InPlace::GetChunkHandle(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetChunkHandleRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::GetChunkHandleRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetChunkHandleResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetChunkHandleRequest, GetChunkHandleResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetChunkHandleResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::FreeBuffer_Impl<Controller::FreeBufferResponse>::FreeBuffer_Impl(::zx::unowned_channel _client_end, uint32_t descriptor) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FreeBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, FreeBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<FreeBufferRequest*>(_write_bytes);
+ _request.descriptor = std::move(descriptor);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(FreeBufferRequest));
+ ::fidl::DecodedMessage<FreeBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::FreeBuffer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::FreeBuffer Controller::SyncClient::FreeBuffer(uint32_t descriptor) {
+ return ResultOf::FreeBuffer(::zx::unowned_channel(this->channel_), std::move(descriptor));
+}
+
+Controller::ResultOf::FreeBuffer Controller::Call::FreeBuffer(::zx::unowned_channel _client_end, uint32_t descriptor) {
+ return ResultOf::FreeBuffer(std::move(_client_end), std::move(descriptor));
+}
+
+template <>
+Controller::UnownedResultOf::FreeBuffer_Impl<Controller::FreeBufferResponse>::FreeBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < FreeBufferRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<FreeBufferResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, FreeBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<FreeBufferRequest*>(_request_buffer.data());
+ _request.descriptor = std::move(descriptor);
+ _request_buffer.set_actual(sizeof(FreeBufferRequest));
+ ::fidl::DecodedMessage<FreeBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::FreeBuffer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::FreeBuffer Controller::SyncClient::FreeBuffer(::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::FreeBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(descriptor), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::FreeBuffer Controller::Call::FreeBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::FreeBuffer(std::move(_client_end), std::move(_request_buffer), std::move(descriptor), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::FreeBufferResponse> Controller::InPlace::FreeBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<FreeBufferRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::FreeBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::FreeBufferResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<FreeBufferRequest, FreeBufferResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::FreeBufferResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Start_Impl<Controller::StartResponse>::Start_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StartRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartRequest));
+ ::fidl::DecodedMessage<StartRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Start(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::Start Controller::SyncClient::Start() {
+ return ResultOf::Start(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::Start Controller::Call::Start(::zx::unowned_channel _client_end) {
+ return ResultOf::Start(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Controller::StartResponse> Controller::InPlace::Start(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(StartRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<StartRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::StartRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StartResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StartRequest, StartResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StartResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Stop_Impl<Controller::StopResponse>::Stop_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StopRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StopRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StopRequest));
+ ::fidl::DecodedMessage<StopRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Stop(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::Stop Controller::SyncClient::Stop() {
+ return ResultOf::Stop(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::Stop Controller::Call::Stop(::zx::unowned_channel _client_end) {
+ return ResultOf::Stop(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Controller::StopResponse> Controller::InPlace::Stop(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(StopRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<StopRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::StopRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StopResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StopRequest, StopResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StopResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Controller::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kController_Initialize_Ordinal:
+ case kController_Initialize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<InitializeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Initialize(std::move(message->allocation),
+ Interface::InitializeCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Terminate_Ordinal:
+ case kController_Terminate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<TerminateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Terminate(
+ Interface::TerminateCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetAllocation_Ordinal:
+ case kController_GetAllocation_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAllocationRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAllocation(
+ Interface::GetAllocationCompleter::Sync(txn));
+ return true;
+ }
+ case kController_AllocateBuffer_Ordinal:
+ case kController_AllocateBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AllocateBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AllocateBuffer(std::move(message->config),
+ Interface::AllocateBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kController_AssignThreadBuffer_Ordinal:
+ case kController_AssignThreadBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AssignThreadBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AssignThreadBuffer(std::move(message->descriptor), std::move(message->thread),
+ Interface::AssignThreadBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ReleaseThreadBuffer_Ordinal:
+ case kController_ReleaseThreadBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReleaseThreadBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReleaseThreadBuffer(std::move(message->descriptor), std::move(message->thread),
+ Interface::ReleaseThreadBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetBufferConfig_Ordinal:
+ case kController_GetBufferConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetBufferConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetBufferConfig(std::move(message->descriptor),
+ Interface::GetBufferConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetBufferState_Ordinal:
+ case kController_GetBufferState_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetBufferStateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetBufferState(std::move(message->descriptor),
+ Interface::GetBufferStateCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetChunkHandle_Ordinal:
+ case kController_GetChunkHandle_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetChunkHandleRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetChunkHandle(std::move(message->descriptor), std::move(message->chunk_num),
+ Interface::GetChunkHandleCompleter::Sync(txn));
+ return true;
+ }
+ case kController_FreeBuffer_Ordinal:
+ case kController_FreeBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<FreeBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->FreeBuffer(std::move(message->descriptor),
+ Interface::FreeBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Start_Ordinal:
+ case kController_Start_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StartRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Start(
+ Interface::StartCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Stop_Ordinal:
+ case kController_Stop_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StopRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Stop(
+ Interface::StopCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Controller::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Controller::Interface::InitializeCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InitializeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ InitializeResponse _response = {};
+ Controller::SetTransactionHeaderFor::InitializeResponse(
+ ::fidl::DecodedMessage<InitializeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InitializeResponse::PrimarySize,
+ InitializeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::InitializeCompleterBase::ReplySuccess() {
+ Controller_Initialize_Response response;
+
+ Reply(Controller_Initialize_Result::WithResponse(&response));
+}
+void Controller::Interface::InitializeCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_Initialize_Result::WithErr(&error));
+}
+
+void Controller::Interface::InitializeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Result result) {
+ if (_buffer.capacity() < InitializeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ InitializeResponse _response = {};
+ Controller::SetTransactionHeaderFor::InitializeResponse(
+ ::fidl::DecodedMessage<InitializeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InitializeResponse::PrimarySize,
+ InitializeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::InitializeCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_Initialize_Response response;
+
+ Reply(std::move(_buffer), Controller_Initialize_Result::WithResponse(&response));
+}
+
+void Controller::Interface::InitializeCompleterBase::Reply(::fidl::DecodedMessage<InitializeResponse> params) {
+ Controller::SetTransactionHeaderFor::InitializeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::TerminateCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TerminateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ TerminateResponse _response = {};
+ Controller::SetTransactionHeaderFor::TerminateResponse(
+ ::fidl::DecodedMessage<TerminateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TerminateResponse::PrimarySize,
+ TerminateResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::TerminateCompleterBase::ReplySuccess() {
+ Controller_Terminate_Response response;
+
+ Reply(Controller_Terminate_Result::WithResponse(&response));
+}
+void Controller::Interface::TerminateCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_Terminate_Result::WithErr(&error));
+}
+
+void Controller::Interface::TerminateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Result result) {
+ if (_buffer.capacity() < TerminateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ TerminateResponse _response = {};
+ Controller::SetTransactionHeaderFor::TerminateResponse(
+ ::fidl::DecodedMessage<TerminateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TerminateResponse::PrimarySize,
+ TerminateResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::TerminateCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_Terminate_Response response;
+
+ Reply(std::move(_buffer), Controller_Terminate_Result::WithResponse(&response));
+}
+
+void Controller::Interface::TerminateCompleterBase::Reply(::fidl::DecodedMessage<TerminateResponse> params) {
+ Controller::SetTransactionHeaderFor::TerminateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetAllocationCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Allocation* allocation) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAllocationResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetAllocationResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetAllocationResponse(
+ ::fidl::DecodedMessage<GetAllocationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAllocationResponse::PrimarySize,
+ GetAllocationResponse::PrimarySize)));
+ _response.allocation = std::move(allocation);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetAllocationCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation* allocation) {
+ if (_buffer.capacity() < GetAllocationResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetAllocationResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetAllocationResponse(
+ ::fidl::DecodedMessage<GetAllocationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAllocationResponse::PrimarySize,
+ GetAllocationResponse::PrimarySize)));
+ _response.allocation = std::move(allocation);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetAllocationCompleterBase::Reply(::fidl::DecodedMessage<GetAllocationResponse> params) {
+ Controller::SetTransactionHeaderFor::GetAllocationResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::AllocateBufferCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocateBufferResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AllocateBufferResponse _response = {};
+ Controller::SetTransactionHeaderFor::AllocateBufferResponse(
+ ::fidl::DecodedMessage<AllocateBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AllocateBufferResponse::PrimarySize,
+ AllocateBufferResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::AllocateBufferCompleterBase::ReplySuccess(uint32_t descriptor) {
+ Controller_AllocateBuffer_Response response;
+ response.descriptor = std::move(descriptor);
+
+ Reply(Controller_AllocateBuffer_Result::WithResponse(&response));
+}
+void Controller::Interface::AllocateBufferCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_AllocateBuffer_Result::WithErr(&error));
+}
+
+void Controller::Interface::AllocateBufferCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Result result) {
+ if (_buffer.capacity() < AllocateBufferResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AllocateBufferResponse _response = {};
+ Controller::SetTransactionHeaderFor::AllocateBufferResponse(
+ ::fidl::DecodedMessage<AllocateBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AllocateBufferResponse::PrimarySize,
+ AllocateBufferResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::AllocateBufferCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint32_t descriptor) {
+ Controller_AllocateBuffer_Response response;
+ response.descriptor = std::move(descriptor);
+
+ Reply(std::move(_buffer), Controller_AllocateBuffer_Result::WithResponse(&response));
+}
+
+void Controller::Interface::AllocateBufferCompleterBase::Reply(::fidl::DecodedMessage<AllocateBufferResponse> params) {
+ Controller::SetTransactionHeaderFor::AllocateBufferResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::AssignThreadBufferCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AssignThreadBufferResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AssignThreadBufferResponse _response = {};
+ Controller::SetTransactionHeaderFor::AssignThreadBufferResponse(
+ ::fidl::DecodedMessage<AssignThreadBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AssignThreadBufferResponse::PrimarySize,
+ AssignThreadBufferResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::AssignThreadBufferCompleterBase::ReplySuccess() {
+ Controller_AssignThreadBuffer_Response response;
+
+ Reply(Controller_AssignThreadBuffer_Result::WithResponse(&response));
+}
+void Controller::Interface::AssignThreadBufferCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_AssignThreadBuffer_Result::WithErr(&error));
+}
+
+void Controller::Interface::AssignThreadBufferCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Result result) {
+ if (_buffer.capacity() < AssignThreadBufferResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AssignThreadBufferResponse _response = {};
+ Controller::SetTransactionHeaderFor::AssignThreadBufferResponse(
+ ::fidl::DecodedMessage<AssignThreadBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AssignThreadBufferResponse::PrimarySize,
+ AssignThreadBufferResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::AssignThreadBufferCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_AssignThreadBuffer_Response response;
+
+ Reply(std::move(_buffer), Controller_AssignThreadBuffer_Result::WithResponse(&response));
+}
+
+void Controller::Interface::AssignThreadBufferCompleterBase::Reply(::fidl::DecodedMessage<AssignThreadBufferResponse> params) {
+ Controller::SetTransactionHeaderFor::AssignThreadBufferResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::ReleaseThreadBufferCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseThreadBufferResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ReleaseThreadBufferResponse _response = {};
+ Controller::SetTransactionHeaderFor::ReleaseThreadBufferResponse(
+ ::fidl::DecodedMessage<ReleaseThreadBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReleaseThreadBufferResponse::PrimarySize,
+ ReleaseThreadBufferResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ReleaseThreadBufferCompleterBase::ReplySuccess() {
+ Controller_ReleaseThreadBuffer_Response response;
+
+ Reply(Controller_ReleaseThreadBuffer_Result::WithResponse(&response));
+}
+void Controller::Interface::ReleaseThreadBufferCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_ReleaseThreadBuffer_Result::WithErr(&error));
+}
+
+void Controller::Interface::ReleaseThreadBufferCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Result result) {
+ if (_buffer.capacity() < ReleaseThreadBufferResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReleaseThreadBufferResponse _response = {};
+ Controller::SetTransactionHeaderFor::ReleaseThreadBufferResponse(
+ ::fidl::DecodedMessage<ReleaseThreadBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReleaseThreadBufferResponse::PrimarySize,
+ ReleaseThreadBufferResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ReleaseThreadBufferCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_ReleaseThreadBuffer_Response response;
+
+ Reply(std::move(_buffer), Controller_ReleaseThreadBuffer_Result::WithResponse(&response));
+}
+
+void Controller::Interface::ReleaseThreadBufferCompleterBase::Reply(::fidl::DecodedMessage<ReleaseThreadBufferResponse> params) {
+ Controller::SetTransactionHeaderFor::ReleaseThreadBufferResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetBufferConfigCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig* config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferConfigResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetBufferConfigResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetBufferConfigResponse(
+ ::fidl::DecodedMessage<GetBufferConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferConfigResponse::PrimarySize,
+ GetBufferConfigResponse::PrimarySize)));
+ _response.config = std::move(config);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetBufferConfigCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig* config) {
+ if (_buffer.capacity() < GetBufferConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetBufferConfigResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetBufferConfigResponse(
+ ::fidl::DecodedMessage<GetBufferConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferConfigResponse::PrimarySize,
+ GetBufferConfigResponse::PrimarySize)));
+ _response.config = std::move(config);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetBufferConfigCompleterBase::Reply(::fidl::DecodedMessage<GetBufferConfigResponse> params) {
+ Controller::SetTransactionHeaderFor::GetBufferConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetBufferStateCompleterBase::Reply(::llcpp::fuchsia::hardware::cpu::insntrace::BufferState* state) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferStateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetBufferStateResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetBufferStateResponse(
+ ::fidl::DecodedMessage<GetBufferStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferStateResponse::PrimarySize,
+ GetBufferStateResponse::PrimarySize)));
+ _response.state = std::move(state);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetBufferStateCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferState* state) {
+ if (_buffer.capacity() < GetBufferStateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetBufferStateResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetBufferStateResponse(
+ ::fidl::DecodedMessage<GetBufferStateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferStateResponse::PrimarySize,
+ GetBufferStateResponse::PrimarySize)));
+ _response.state = std::move(state);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetBufferStateCompleterBase::Reply(::fidl::DecodedMessage<GetBufferStateResponse> params) {
+ Controller::SetTransactionHeaderFor::GetBufferStateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetChunkHandleCompleterBase::Reply(::zx::vmo buffer) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChunkHandleResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetChunkHandleResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetChunkHandleResponse(
+ ::fidl::DecodedMessage<GetChunkHandleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetChunkHandleResponse::PrimarySize,
+ GetChunkHandleResponse::PrimarySize)));
+ _response.buffer = std::move(buffer);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChunkHandleResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetChunkHandleResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetChunkHandleCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo buffer) {
+ if (_buffer.capacity() < GetChunkHandleResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetChunkHandleResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetChunkHandleResponse(
+ ::fidl::DecodedMessage<GetChunkHandleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetChunkHandleResponse::PrimarySize,
+ GetChunkHandleResponse::PrimarySize)));
+ _response.buffer = std::move(buffer);
+ _buffer.set_actual(sizeof(GetChunkHandleResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetChunkHandleResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetChunkHandleCompleterBase::Reply(::fidl::DecodedMessage<GetChunkHandleResponse> params) {
+ Controller::SetTransactionHeaderFor::GetChunkHandleResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::FreeBufferCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FreeBufferResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<FreeBufferResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::FreeBufferResponse(
+ ::fidl::DecodedMessage<FreeBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ FreeBufferResponse::PrimarySize,
+ FreeBufferResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(FreeBufferResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<FreeBufferResponse>(std::move(_response_bytes)));
+}
+
+
+void Controller::Interface::StartCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StartResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::StartResponse(
+ ::fidl::DecodedMessage<StartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartResponse::PrimarySize,
+ StartResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartResponse>(std::move(_response_bytes)));
+}
+
+
+void Controller::Interface::StopCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StopResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StopResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::StopResponse(
+ ::fidl::DecodedMessage<StopResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StopResponse::PrimarySize,
+ StopResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StopResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StopResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Controller::SetTransactionHeaderFor::InitializeRequest(const ::fidl::DecodedMessage<Controller::InitializeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Initialize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::InitializeResponse(const ::fidl::DecodedMessage<Controller::InitializeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Initialize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::TerminateRequest(const ::fidl::DecodedMessage<Controller::TerminateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Terminate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::TerminateResponse(const ::fidl::DecodedMessage<Controller::TerminateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Terminate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetAllocationRequest(const ::fidl::DecodedMessage<Controller::GetAllocationRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetAllocation_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetAllocationResponse(const ::fidl::DecodedMessage<Controller::GetAllocationResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetAllocation_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::AllocateBufferRequest(const ::fidl::DecodedMessage<Controller::AllocateBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_AllocateBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::AllocateBufferResponse(const ::fidl::DecodedMessage<Controller::AllocateBufferResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_AllocateBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::AssignThreadBufferRequest(const ::fidl::DecodedMessage<Controller::AssignThreadBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_AssignThreadBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::AssignThreadBufferResponse(const ::fidl::DecodedMessage<Controller::AssignThreadBufferResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_AssignThreadBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ReleaseThreadBufferRequest(const ::fidl::DecodedMessage<Controller::ReleaseThreadBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ReleaseThreadBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ReleaseThreadBufferResponse(const ::fidl::DecodedMessage<Controller::ReleaseThreadBufferResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ReleaseThreadBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetBufferConfigRequest(const ::fidl::DecodedMessage<Controller::GetBufferConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetBufferConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetBufferConfigResponse(const ::fidl::DecodedMessage<Controller::GetBufferConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetBufferConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetBufferStateRequest(const ::fidl::DecodedMessage<Controller::GetBufferStateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetBufferState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetBufferStateResponse(const ::fidl::DecodedMessage<Controller::GetBufferStateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetBufferState_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetChunkHandleRequest(const ::fidl::DecodedMessage<Controller::GetChunkHandleRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetChunkHandle_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetChunkHandleResponse(const ::fidl::DecodedMessage<Controller::GetChunkHandleResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetChunkHandle_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::FreeBufferRequest(const ::fidl::DecodedMessage<Controller::FreeBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_FreeBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::FreeBufferResponse(const ::fidl::DecodedMessage<Controller::FreeBufferResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_FreeBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::StartRequest(const ::fidl::DecodedMessage<Controller::StartRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Start_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::StartResponse(const ::fidl::DecodedMessage<Controller::StartResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Start_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::StopRequest(const ::fidl::DecodedMessage<Controller::StopRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Stop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::StopResponse(const ::fidl::DecodedMessage<Controller::StopResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Stop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace insntrace
+} // namespace cpu
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-cpu-insntrace/gen/llcpp/include/fuchsia/hardware/cpu/insntrace/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-cpu-insntrace/gen/llcpp/include/fuchsia/hardware/cpu/insntrace/llcpp/fidl.h
new file mode 100644
index 0000000..ddff997
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-cpu-insntrace/gen/llcpp/include/fuchsia/hardware/cpu/insntrace/llcpp/fidl.h
@@ -0,0 +1,2159 @@
+// 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/thread.h>
+#include <lib/zx/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace cpu {
+namespace insntrace {
+
+enum class Mode : uint8_t {
+ CPU = 0u,
+ THREAD = 1u,
+};
+
+
+struct Allocation;
+struct Controller_Terminate_Response;
+struct Controller_Terminate_Result;
+struct Controller_ReleaseThreadBuffer_Response;
+struct Controller_ReleaseThreadBuffer_Result;
+struct Controller_Initialize_Response;
+struct Controller_Initialize_Result;
+struct Controller_AssignThreadBuffer_Response;
+struct Controller_AssignThreadBuffer_Result;
+struct BufferState;
+struct Controller_AllocateBuffer_Response;
+struct Controller_AllocateBuffer_Result;
+struct AddressRange;
+struct BufferConfig;
+class Controller;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_Terminate_ResultTable;
+
+struct Controller_Terminate_Result {
+ Controller_Terminate_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_Terminate_Result WithResponse(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response* val) {
+ Controller_Terminate_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_Terminate_Result WithErr(int32_t* val) {
+ Controller_Terminate_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_Terminate_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_ReleaseThreadBuffer_ResultTable;
+
+struct Controller_ReleaseThreadBuffer_Result {
+ Controller_ReleaseThreadBuffer_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_ReleaseThreadBuffer_Result WithResponse(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response* val) {
+ Controller_ReleaseThreadBuffer_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_ReleaseThreadBuffer_Result WithErr(int32_t* val) {
+ Controller_ReleaseThreadBuffer_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_ReleaseThreadBuffer_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_Initialize_ResultTable;
+
+struct Controller_Initialize_Result {
+ Controller_Initialize_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_Initialize_Result WithResponse(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response* val) {
+ Controller_Initialize_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_Initialize_Result WithErr(int32_t* val) {
+ Controller_Initialize_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_Initialize_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_AssignThreadBuffer_ResultTable;
+
+struct Controller_AssignThreadBuffer_Result {
+ Controller_AssignThreadBuffer_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_AssignThreadBuffer_Result WithResponse(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response* val) {
+ Controller_AssignThreadBuffer_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_AssignThreadBuffer_Result WithErr(int32_t* val) {
+ Controller_AssignThreadBuffer_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_AssignThreadBuffer_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_AllocateBuffer_ResultTable;
+
+struct Controller_AllocateBuffer_Result {
+ Controller_AllocateBuffer_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_AllocateBuffer_Result WithResponse(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response* val) {
+ Controller_AllocateBuffer_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_AllocateBuffer_Result WithErr(int32_t* val) {
+ Controller_AllocateBuffer_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_AllocateBuffer_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_AllocationTable;
+
+// The allocation configuration of a trace.
+struct Allocation {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_AllocationTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Mode mode = {};
+
+ uint16_t num_traces = {};
+};
+
+// The maximum number of traces that can be collected at once.
+// A "trace" is the instruction stream for one entity, cpu or thread.
+constexpr uint16_t MAX_NUM_TRACES = 64u;
+
+// The maximum number of supported address ranges.
+constexpr uint16_t MAX_NUM_ADDR_RANGES = 2u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_Terminate_ResponseTable;
+
+struct Controller_Terminate_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_Terminate_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_ReleaseThreadBuffer_ResponseTable;
+
+struct Controller_ReleaseThreadBuffer_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_ReleaseThreadBuffer_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_Initialize_ResponseTable;
+
+struct Controller_Initialize_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_Initialize_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_AssignThreadBuffer_ResponseTable;
+
+struct Controller_AssignThreadBuffer_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_AssignThreadBuffer_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_BufferStateTable;
+
+// A buffer's runtime state.
+struct BufferState {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_BufferStateTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // This is the offset in the buffer where tracing stopped (treating all
+ // buffers as one large one). If using a circular buffer then all of the
+ // buffer may contain data, there's no current way to know if tracing
+ // wrapped without scanning records.
+ uint64_t capture_end = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_Controller_AllocateBuffer_ResponseTable;
+
+struct Controller_AllocateBuffer_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_Controller_AllocateBuffer_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t descriptor = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_AddressRangeTable;
+
+// An address range, as [start,end].
+struct AddressRange {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_AddressRangeTable;
+ 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;
+
+ uint64_t start = {};
+
+ uint64_t end = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_BufferConfigTable;
+
+// A buffer's configuration.
+struct BufferConfig {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_BufferConfigTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 64;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // A "buffer" is made up of |num_chunks| chunks with each chunk having
+ // size |1<<chunk_order| pages.
+ uint32_t num_chunks = {};
+
+ // log2 of the number of pages
+ uint32_t chunk_order = {};
+
+ // If true then use circular buffering.
+ bool is_circular = {};
+
+ // The value of the control register.
+ uint64_t ctl = {};
+
+ // If non-zero then the address space of the instruction must match in
+ // order for the instruction to be traced. On x86 architectures the
+ // address space is specified by CR3.
+ uint64_t address_space_match = {};
+
+ // If non-zero, tracing is restricted to these address ranges.
+ // TODO(dje): There's only two, and vectors don't currently work here,
+ // so spell these out individually
+ ::llcpp::fuchsia::hardware::cpu::insntrace::AddressRange address_range_0 = {};
+
+ ::llcpp::fuchsia::hardware::cpu::insntrace::AddressRange address_range_1 = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerInitializeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerInitializeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerTerminateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerTerminateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetAllocationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetAllocationResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerAllocateBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerAllocateBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerAssignThreadBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerAssignThreadBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerReleaseThreadBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerReleaseThreadBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferStateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferStateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetChunkHandleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerGetChunkHandleResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerFreeBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerFreeBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerStartResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_cpu_insntrace_ControllerStopResponseTable;
+
+class Controller final {
+ Controller() = delete;
+ public:
+
+ struct InitializeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerInitializeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct InitializeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerInitializeRequestTable;
+ 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 = InitializeResponse;
+ };
+
+ struct TerminateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerTerminateResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using TerminateRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAllocationResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation* allocation;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerGetAllocationResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ 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;
+ };
+ using GetAllocationRequest = ::fidl::AnyZeroArgMessage;
+
+ struct AllocateBufferResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerAllocateBufferResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AllocateBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerAllocateBufferRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = AllocateBufferResponse;
+ };
+
+ struct AssignThreadBufferResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerAssignThreadBufferResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AssignThreadBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t descriptor;
+ ::zx::thread thread;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerAssignThreadBufferRequestTable;
+ 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 = AssignThreadBufferResponse;
+ };
+
+ struct ReleaseThreadBufferResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerReleaseThreadBufferResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ReleaseThreadBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t descriptor;
+ ::zx::thread thread;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerReleaseThreadBufferRequestTable;
+ 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 = ReleaseThreadBufferResponse;
+ };
+
+ struct GetBufferConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig* config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferConfigResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ static constexpr uint32_t MaxOutOfLine = 64;
+ 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 GetBufferConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t descriptor;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferConfigRequestTable;
+ 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 = GetBufferConfigResponse;
+ };
+
+ struct GetBufferStateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::cpu::insntrace::BufferState* state;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferStateResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ 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 GetBufferStateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t descriptor;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerGetBufferStateRequestTable;
+ 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 = GetBufferStateResponse;
+ };
+
+ struct GetChunkHandleResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo buffer;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerGetChunkHandleResponseTable;
+ 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;
+ };
+ struct GetChunkHandleRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t descriptor;
+ uint32_t chunk_num;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerGetChunkHandleRequestTable;
+ 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 = GetChunkHandleResponse;
+ };
+
+ using FreeBufferResponse = ::fidl::AnyZeroArgMessage;
+ struct FreeBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t descriptor;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_cpu_insntrace_ControllerFreeBufferRequestTable;
+ 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 StartResponse = ::fidl::AnyZeroArgMessage;
+ using StartRequest = ::fidl::AnyZeroArgMessage;
+
+ using StopResponse = ::fidl::AnyZeroArgMessage;
+ using StopRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Initialize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Initialize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation);
+ ~Initialize_Impl() = default;
+ Initialize_Impl(Initialize_Impl&& other) = default;
+ Initialize_Impl& operator=(Initialize_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 Terminate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Terminate_Impl(::zx::unowned_channel _client_end);
+ ~Terminate_Impl() = default;
+ Terminate_Impl(Terminate_Impl&& other) = default;
+ Terminate_Impl& operator=(Terminate_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 GetAllocation_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAllocation_Impl(::zx::unowned_channel _client_end);
+ ~GetAllocation_Impl() = default;
+ GetAllocation_Impl(GetAllocation_Impl&& other) = default;
+ GetAllocation_Impl& operator=(GetAllocation_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 AllocateBuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AllocateBuffer_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config);
+ ~AllocateBuffer_Impl() = default;
+ AllocateBuffer_Impl(AllocateBuffer_Impl&& other) = default;
+ AllocateBuffer_Impl& operator=(AllocateBuffer_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 AssignThreadBuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AssignThreadBuffer_Impl(::zx::unowned_channel _client_end, uint32_t descriptor, ::zx::thread thread);
+ ~AssignThreadBuffer_Impl() = default;
+ AssignThreadBuffer_Impl(AssignThreadBuffer_Impl&& other) = default;
+ AssignThreadBuffer_Impl& operator=(AssignThreadBuffer_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 ReleaseThreadBuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReleaseThreadBuffer_Impl(::zx::unowned_channel _client_end, uint32_t descriptor, ::zx::thread thread);
+ ~ReleaseThreadBuffer_Impl() = default;
+ ReleaseThreadBuffer_Impl(ReleaseThreadBuffer_Impl&& other) = default;
+ ReleaseThreadBuffer_Impl& operator=(ReleaseThreadBuffer_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 GetBufferConfig_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetBufferConfig_Impl(::zx::unowned_channel _client_end, uint32_t descriptor);
+ ~GetBufferConfig_Impl() = default;
+ GetBufferConfig_Impl(GetBufferConfig_Impl&& other) = default;
+ GetBufferConfig_Impl& operator=(GetBufferConfig_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 GetBufferState_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetBufferState_Impl(::zx::unowned_channel _client_end, uint32_t descriptor);
+ ~GetBufferState_Impl() = default;
+ GetBufferState_Impl(GetBufferState_Impl&& other) = default;
+ GetBufferState_Impl& operator=(GetBufferState_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 GetChunkHandle_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetChunkHandle_Impl(::zx::unowned_channel _client_end, uint32_t descriptor, uint32_t chunk_num);
+ ~GetChunkHandle_Impl() = default;
+ GetChunkHandle_Impl(GetChunkHandle_Impl&& other) = default;
+ GetChunkHandle_Impl& operator=(GetChunkHandle_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 FreeBuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ FreeBuffer_Impl(::zx::unowned_channel _client_end, uint32_t descriptor);
+ ~FreeBuffer_Impl() = default;
+ FreeBuffer_Impl(FreeBuffer_Impl&& other) = default;
+ FreeBuffer_Impl& operator=(FreeBuffer_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 Start_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Start_Impl(::zx::unowned_channel _client_end);
+ ~Start_Impl() = default;
+ Start_Impl(Start_Impl&& other) = default;
+ Start_Impl& operator=(Start_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 Stop_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Stop_Impl(::zx::unowned_channel _client_end);
+ ~Stop_Impl() = default;
+ Stop_Impl(Stop_Impl&& other) = default;
+ Stop_Impl& operator=(Stop_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 Initialize = Initialize_Impl<InitializeResponse>;
+ using Terminate = Terminate_Impl<TerminateResponse>;
+ using GetAllocation = GetAllocation_Impl<GetAllocationResponse>;
+ using AllocateBuffer = AllocateBuffer_Impl<AllocateBufferResponse>;
+ using AssignThreadBuffer = AssignThreadBuffer_Impl<AssignThreadBufferResponse>;
+ using ReleaseThreadBuffer = ReleaseThreadBuffer_Impl<ReleaseThreadBufferResponse>;
+ using GetBufferConfig = GetBufferConfig_Impl<GetBufferConfigResponse>;
+ using GetBufferState = GetBufferState_Impl<GetBufferStateResponse>;
+ using GetChunkHandle = GetChunkHandle_Impl<GetChunkHandleResponse>;
+ using FreeBuffer = FreeBuffer_Impl<FreeBufferResponse>;
+ using Start = Start_Impl<StartResponse>;
+ using Stop = Stop_Impl<StopResponse>;
+ };
+
+ // 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 Initialize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Initialize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation, ::fidl::BytePart _response_buffer);
+ ~Initialize_Impl() = default;
+ Initialize_Impl(Initialize_Impl&& other) = default;
+ Initialize_Impl& operator=(Initialize_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 Terminate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Terminate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Terminate_Impl() = default;
+ Terminate_Impl(Terminate_Impl&& other) = default;
+ Terminate_Impl& operator=(Terminate_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 GetAllocation_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAllocation_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAllocation_Impl() = default;
+ GetAllocation_Impl(GetAllocation_Impl&& other) = default;
+ GetAllocation_Impl& operator=(GetAllocation_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 AllocateBuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AllocateBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config, ::fidl::BytePart _response_buffer);
+ ~AllocateBuffer_Impl() = default;
+ AllocateBuffer_Impl(AllocateBuffer_Impl&& other) = default;
+ AllocateBuffer_Impl& operator=(AllocateBuffer_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 AssignThreadBuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AssignThreadBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer);
+ ~AssignThreadBuffer_Impl() = default;
+ AssignThreadBuffer_Impl(AssignThreadBuffer_Impl&& other) = default;
+ AssignThreadBuffer_Impl& operator=(AssignThreadBuffer_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 ReleaseThreadBuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReleaseThreadBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer);
+ ~ReleaseThreadBuffer_Impl() = default;
+ ReleaseThreadBuffer_Impl(ReleaseThreadBuffer_Impl&& other) = default;
+ ReleaseThreadBuffer_Impl& operator=(ReleaseThreadBuffer_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 GetBufferConfig_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetBufferConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+ ~GetBufferConfig_Impl() = default;
+ GetBufferConfig_Impl(GetBufferConfig_Impl&& other) = default;
+ GetBufferConfig_Impl& operator=(GetBufferConfig_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 GetBufferState_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetBufferState_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+ ~GetBufferState_Impl() = default;
+ GetBufferState_Impl(GetBufferState_Impl&& other) = default;
+ GetBufferState_Impl& operator=(GetBufferState_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 GetChunkHandle_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetChunkHandle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, uint32_t chunk_num, ::fidl::BytePart _response_buffer);
+ ~GetChunkHandle_Impl() = default;
+ GetChunkHandle_Impl(GetChunkHandle_Impl&& other) = default;
+ GetChunkHandle_Impl& operator=(GetChunkHandle_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 FreeBuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ FreeBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+ ~FreeBuffer_Impl() = default;
+ FreeBuffer_Impl(FreeBuffer_Impl&& other) = default;
+ FreeBuffer_Impl& operator=(FreeBuffer_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 Start_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Start_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Start_Impl() = default;
+ Start_Impl(Start_Impl&& other) = default;
+ Start_Impl& operator=(Start_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 Stop_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Stop_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Stop_Impl() = default;
+ Stop_Impl(Stop_Impl&& other) = default;
+ Stop_Impl& operator=(Stop_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 Initialize = Initialize_Impl<InitializeResponse>;
+ using Terminate = Terminate_Impl<TerminateResponse>;
+ using GetAllocation = GetAllocation_Impl<GetAllocationResponse>;
+ using AllocateBuffer = AllocateBuffer_Impl<AllocateBufferResponse>;
+ using AssignThreadBuffer = AssignThreadBuffer_Impl<AssignThreadBufferResponse>;
+ using ReleaseThreadBuffer = ReleaseThreadBuffer_Impl<ReleaseThreadBufferResponse>;
+ using GetBufferConfig = GetBufferConfig_Impl<GetBufferConfigResponse>;
+ using GetBufferState = GetBufferState_Impl<GetBufferStateResponse>;
+ using GetChunkHandle = GetChunkHandle_Impl<GetChunkHandleResponse>;
+ using FreeBuffer = FreeBuffer_Impl<FreeBufferResponse>;
+ using Start = Start_Impl<StartResponse>;
+ using Stop = Stop_Impl<StopResponse>;
+ };
+
+ 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_; }
+
+ // Initialize the trace.
+ // This does not include allocating space for the trace buffers, that is
+ // done later by |AllocateBuffer()|.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Initialize Initialize(::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation);
+
+ // Initialize the trace.
+ // This does not include allocating space for the trace buffers, that is
+ // done later by |AllocateBuffer()|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Initialize Initialize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation, ::fidl::BytePart _response_buffer);
+
+ // Free all trace buffers and any other resources allocated for the trace.
+ // This is also done when the connection is closed (as well as stopping
+ // the trace).
+ // May be called multiple times.
+ // This can only fail when tracing in THREAD mode where tracing is
+ // terminated differently, in which case the error is `ZX_ERR_BAD_STATE`.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Terminate Terminate();
+
+ // Free all trace buffers and any other resources allocated for the trace.
+ // This is also done when the connection is closed (as well as stopping
+ // the trace).
+ // May be called multiple times.
+ // This can only fail when tracing in THREAD mode where tracing is
+ // terminated differently, in which case the error is `ZX_ERR_BAD_STATE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Terminate Terminate(::fidl::BytePart _response_buffer);
+
+ // Return the trace allocation configuration.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAllocation GetAllocation();
+
+ // Return the trace allocation configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAllocation GetAllocation(::fidl::BytePart _response_buffer);
+
+ // Allocate a trace buffer.
+ // When tracing cpus, buffers are auto-assigned to cpus: the resulting
+ // trace buffer descriptor is the number of the cpu using the buffer.
+ // Allocates 128 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AllocateBuffer AllocateBuffer(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config);
+
+ // Allocate a trace buffer.
+ // When tracing cpus, buffers are auto-assigned to cpus: the resulting
+ // trace buffer descriptor is the number of the cpu using the buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AllocateBuffer AllocateBuffer(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config, ::fidl::BytePart _response_buffer);
+
+ // Assign a buffer to a thread.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AssignThreadBuffer AssignThreadBuffer(uint32_t descriptor, ::zx::thread thread);
+
+ // Assign a buffer to a thread.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AssignThreadBuffer AssignThreadBuffer(::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer);
+
+ // Release a previously assigned buffer from a thread.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReleaseThreadBuffer ReleaseThreadBuffer(uint32_t descriptor, ::zx::thread thread);
+
+ // Release a previously assigned buffer from a thread.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReleaseThreadBuffer ReleaseThreadBuffer(::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer);
+
+ // Fetch a buffer's configuration.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetBufferConfig GetBufferConfig(uint32_t descriptor);
+
+ // Fetch a buffer's configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetBufferConfig GetBufferConfig(::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+
+ // Fetch runtime information about a buffer.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetBufferState GetBufferState(uint32_t descriptor);
+
+ // Fetch runtime information about a buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetBufferState GetBufferState(::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+
+ // Fetch the handle of a chunk of a trace buffer.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetChunkHandle GetChunkHandle(uint32_t descriptor, uint32_t chunk_num);
+
+ // Fetch the handle of a chunk of a trace buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetChunkHandle GetChunkHandle(::fidl::BytePart _request_buffer, uint32_t descriptor, uint32_t chunk_num, ::fidl::BytePart _response_buffer);
+
+ // Free a previously allocated trace buffer.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::FreeBuffer FreeBuffer(uint32_t descriptor);
+
+ // Free a previously allocated trace buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::FreeBuffer FreeBuffer(::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+
+ // Start tracing.
+ // Must be called after |Initialize()| + |AllocateBuffer()|,
+ // with tracing off.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Start Start();
+
+
+ // Stop tracing.
+ // May be called any time after |Allocate()| has been called and before
+ // |Free()|. If called at other times the call is ignored.
+ // May be called multiple times.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Stop Stop();
+
+
+ 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:
+
+ // Initialize the trace.
+ // This does not include allocating space for the trace buffers, that is
+ // done later by |AllocateBuffer()|.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Initialize Initialize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation);
+
+ // Initialize the trace.
+ // This does not include allocating space for the trace buffers, that is
+ // done later by |AllocateBuffer()|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Initialize Initialize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation, ::fidl::BytePart _response_buffer);
+
+ // Free all trace buffers and any other resources allocated for the trace.
+ // This is also done when the connection is closed (as well as stopping
+ // the trace).
+ // May be called multiple times.
+ // This can only fail when tracing in THREAD mode where tracing is
+ // terminated differently, in which case the error is `ZX_ERR_BAD_STATE`.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Terminate Terminate(::zx::unowned_channel _client_end);
+
+ // Free all trace buffers and any other resources allocated for the trace.
+ // This is also done when the connection is closed (as well as stopping
+ // the trace).
+ // May be called multiple times.
+ // This can only fail when tracing in THREAD mode where tracing is
+ // terminated differently, in which case the error is `ZX_ERR_BAD_STATE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Terminate Terminate(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Return the trace allocation configuration.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAllocation GetAllocation(::zx::unowned_channel _client_end);
+
+ // Return the trace allocation configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAllocation GetAllocation(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocate a trace buffer.
+ // When tracing cpus, buffers are auto-assigned to cpus: the resulting
+ // trace buffer descriptor is the number of the cpu using the buffer.
+ // Allocates 128 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AllocateBuffer AllocateBuffer(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config);
+
+ // Allocate a trace buffer.
+ // When tracing cpus, buffers are auto-assigned to cpus: the resulting
+ // trace buffer descriptor is the number of the cpu using the buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AllocateBuffer AllocateBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config, ::fidl::BytePart _response_buffer);
+
+ // Assign a buffer to a thread.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AssignThreadBuffer AssignThreadBuffer(::zx::unowned_channel _client_end, uint32_t descriptor, ::zx::thread thread);
+
+ // Assign a buffer to a thread.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AssignThreadBuffer AssignThreadBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer);
+
+ // Release a previously assigned buffer from a thread.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReleaseThreadBuffer ReleaseThreadBuffer(::zx::unowned_channel _client_end, uint32_t descriptor, ::zx::thread thread);
+
+ // Release a previously assigned buffer from a thread.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReleaseThreadBuffer ReleaseThreadBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::zx::thread thread, ::fidl::BytePart _response_buffer);
+
+ // Fetch a buffer's configuration.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetBufferConfig GetBufferConfig(::zx::unowned_channel _client_end, uint32_t descriptor);
+
+ // Fetch a buffer's configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetBufferConfig GetBufferConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+
+ // Fetch runtime information about a buffer.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetBufferState GetBufferState(::zx::unowned_channel _client_end, uint32_t descriptor);
+
+ // Fetch runtime information about a buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetBufferState GetBufferState(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+
+ // Fetch the handle of a chunk of a trace buffer.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetChunkHandle GetChunkHandle(::zx::unowned_channel _client_end, uint32_t descriptor, uint32_t chunk_num);
+
+ // Fetch the handle of a chunk of a trace buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetChunkHandle GetChunkHandle(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, uint32_t chunk_num, ::fidl::BytePart _response_buffer);
+
+ // Free a previously allocated trace buffer.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::FreeBuffer FreeBuffer(::zx::unowned_channel _client_end, uint32_t descriptor);
+
+ // Free a previously allocated trace buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::FreeBuffer FreeBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+
+ // Start tracing.
+ // Must be called after |Initialize()| + |AllocateBuffer()|,
+ // with tracing off.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Start Start(::zx::unowned_channel _client_end);
+
+
+ // Stop tracing.
+ // May be called any time after |Allocate()| has been called and before
+ // |Free()|. If called at other times the call is ignored.
+ // May be called multiple times.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Stop Stop(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // Initialize the trace.
+ // This does not include allocating space for the trace buffers, that is
+ // done later by |AllocateBuffer()|.
+ static ::fidl::DecodeResult<InitializeResponse> Initialize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<InitializeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Free all trace buffers and any other resources allocated for the trace.
+ // This is also done when the connection is closed (as well as stopping
+ // the trace).
+ // May be called multiple times.
+ // This can only fail when tracing in THREAD mode where tracing is
+ // terminated differently, in which case the error is `ZX_ERR_BAD_STATE`.
+ static ::fidl::DecodeResult<TerminateResponse> Terminate(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return the trace allocation configuration.
+ static ::fidl::DecodeResult<GetAllocationResponse> GetAllocation(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Allocate a trace buffer.
+ // When tracing cpus, buffers are auto-assigned to cpus: the resulting
+ // trace buffer descriptor is the number of the cpu using the buffer.
+ static ::fidl::DecodeResult<AllocateBufferResponse> AllocateBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateBufferRequest> params, ::fidl::BytePart response_buffer);
+
+ // Assign a buffer to a thread.
+ static ::fidl::DecodeResult<AssignThreadBufferResponse> AssignThreadBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AssignThreadBufferRequest> params, ::fidl::BytePart response_buffer);
+
+ // Release a previously assigned buffer from a thread.
+ static ::fidl::DecodeResult<ReleaseThreadBufferResponse> ReleaseThreadBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseThreadBufferRequest> params, ::fidl::BytePart response_buffer);
+
+ // Fetch a buffer's configuration.
+ static ::fidl::DecodeResult<GetBufferConfigResponse> GetBufferConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferConfigRequest> params, ::fidl::BytePart response_buffer);
+
+ // Fetch runtime information about a buffer.
+ static ::fidl::DecodeResult<GetBufferStateResponse> GetBufferState(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferStateRequest> params, ::fidl::BytePart response_buffer);
+
+ // Fetch the handle of a chunk of a trace buffer.
+ static ::fidl::DecodeResult<GetChunkHandleResponse> GetChunkHandle(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetChunkHandleRequest> params, ::fidl::BytePart response_buffer);
+
+ // Free a previously allocated trace buffer.
+ static ::fidl::DecodeResult<FreeBufferResponse> FreeBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<FreeBufferRequest> params, ::fidl::BytePart response_buffer);
+
+ // Start tracing.
+ // Must be called after |Initialize()| + |AllocateBuffer()|,
+ // with tracing off.
+ static ::fidl::DecodeResult<StartResponse> Start(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Stop tracing.
+ // May be called any time after |Allocate()| has been called and before
+ // |Free()|. If called at other times the call is ignored.
+ // May be called multiple times.
+ static ::fidl::DecodeResult<StopResponse> Stop(::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 = Controller;
+ using _Base = ::fidl::CompleterBase;
+
+ class InitializeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<InitializeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using InitializeCompleter = ::fidl::Completer<InitializeCompleterBase>;
+
+ virtual void Initialize(::llcpp::fuchsia::hardware::cpu::insntrace::Allocation allocation, InitializeCompleter::Sync _completer) = 0;
+
+ class TerminateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<TerminateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using TerminateCompleter = ::fidl::Completer<TerminateCompleterBase>;
+
+ virtual void Terminate(TerminateCompleter::Sync _completer) = 0;
+
+ class GetAllocationCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Allocation* allocation);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation* allocation);
+ void Reply(::fidl::DecodedMessage<GetAllocationResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAllocationCompleter = ::fidl::Completer<GetAllocationCompleterBase>;
+
+ virtual void GetAllocation(GetAllocationCompleter::Sync _completer) = 0;
+
+ class AllocateBufferCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Result result);
+ void ReplySuccess(uint32_t descriptor);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint32_t descriptor);
+ void Reply(::fidl::DecodedMessage<AllocateBufferResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AllocateBufferCompleter = ::fidl::Completer<AllocateBufferCompleterBase>;
+
+ virtual void AllocateBuffer(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig config, AllocateBufferCompleter::Sync _completer) = 0;
+
+ class AssignThreadBufferCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<AssignThreadBufferResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AssignThreadBufferCompleter = ::fidl::Completer<AssignThreadBufferCompleterBase>;
+
+ virtual void AssignThreadBuffer(uint32_t descriptor, ::zx::thread thread, AssignThreadBufferCompleter::Sync _completer) = 0;
+
+ class ReleaseThreadBufferCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ReleaseThreadBufferResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReleaseThreadBufferCompleter = ::fidl::Completer<ReleaseThreadBufferCompleterBase>;
+
+ virtual void ReleaseThreadBuffer(uint32_t descriptor, ::zx::thread thread, ReleaseThreadBufferCompleter::Sync _completer) = 0;
+
+ class GetBufferConfigCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig* config);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig* config);
+ void Reply(::fidl::DecodedMessage<GetBufferConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetBufferConfigCompleter = ::fidl::Completer<GetBufferConfigCompleterBase>;
+
+ virtual void GetBufferConfig(uint32_t descriptor, GetBufferConfigCompleter::Sync _completer) = 0;
+
+ class GetBufferStateCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::cpu::insntrace::BufferState* state);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::cpu::insntrace::BufferState* state);
+ void Reply(::fidl::DecodedMessage<GetBufferStateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetBufferStateCompleter = ::fidl::Completer<GetBufferStateCompleterBase>;
+
+ virtual void GetBufferState(uint32_t descriptor, GetBufferStateCompleter::Sync _completer) = 0;
+
+ class GetChunkHandleCompleterBase : public _Base {
+ public:
+ void Reply(::zx::vmo buffer);
+ void Reply(::fidl::BytePart _buffer, ::zx::vmo buffer);
+ void Reply(::fidl::DecodedMessage<GetChunkHandleResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetChunkHandleCompleter = ::fidl::Completer<GetChunkHandleCompleterBase>;
+
+ virtual void GetChunkHandle(uint32_t descriptor, uint32_t chunk_num, GetChunkHandleCompleter::Sync _completer) = 0;
+
+ class FreeBufferCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using FreeBufferCompleter = ::fidl::Completer<FreeBufferCompleterBase>;
+
+ virtual void FreeBuffer(uint32_t descriptor, FreeBufferCompleter::Sync _completer) = 0;
+
+ class StartCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StartCompleter = ::fidl::Completer<StartCompleterBase>;
+
+ virtual void Start(StartCompleter::Sync _completer) = 0;
+
+ class StopCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StopCompleter = ::fidl::Completer<StopCompleterBase>;
+
+ virtual void Stop(StopCompleter::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 InitializeRequest(const ::fidl::DecodedMessage<Controller::InitializeRequest>& _msg);
+ static void InitializeResponse(const ::fidl::DecodedMessage<Controller::InitializeResponse>& _msg);
+ static void TerminateRequest(const ::fidl::DecodedMessage<Controller::TerminateRequest>& _msg);
+ static void TerminateResponse(const ::fidl::DecodedMessage<Controller::TerminateResponse>& _msg);
+ static void GetAllocationRequest(const ::fidl::DecodedMessage<Controller::GetAllocationRequest>& _msg);
+ static void GetAllocationResponse(const ::fidl::DecodedMessage<Controller::GetAllocationResponse>& _msg);
+ static void AllocateBufferRequest(const ::fidl::DecodedMessage<Controller::AllocateBufferRequest>& _msg);
+ static void AllocateBufferResponse(const ::fidl::DecodedMessage<Controller::AllocateBufferResponse>& _msg);
+ static void AssignThreadBufferRequest(const ::fidl::DecodedMessage<Controller::AssignThreadBufferRequest>& _msg);
+ static void AssignThreadBufferResponse(const ::fidl::DecodedMessage<Controller::AssignThreadBufferResponse>& _msg);
+ static void ReleaseThreadBufferRequest(const ::fidl::DecodedMessage<Controller::ReleaseThreadBufferRequest>& _msg);
+ static void ReleaseThreadBufferResponse(const ::fidl::DecodedMessage<Controller::ReleaseThreadBufferResponse>& _msg);
+ static void GetBufferConfigRequest(const ::fidl::DecodedMessage<Controller::GetBufferConfigRequest>& _msg);
+ static void GetBufferConfigResponse(const ::fidl::DecodedMessage<Controller::GetBufferConfigResponse>& _msg);
+ static void GetBufferStateRequest(const ::fidl::DecodedMessage<Controller::GetBufferStateRequest>& _msg);
+ static void GetBufferStateResponse(const ::fidl::DecodedMessage<Controller::GetBufferStateResponse>& _msg);
+ static void GetChunkHandleRequest(const ::fidl::DecodedMessage<Controller::GetChunkHandleRequest>& _msg);
+ static void GetChunkHandleResponse(const ::fidl::DecodedMessage<Controller::GetChunkHandleResponse>& _msg);
+ static void FreeBufferRequest(const ::fidl::DecodedMessage<Controller::FreeBufferRequest>& _msg);
+ static void FreeBufferResponse(const ::fidl::DecodedMessage<Controller::FreeBufferResponse>& _msg);
+ static void StartRequest(const ::fidl::DecodedMessage<Controller::StartRequest>& _msg);
+ static void StartResponse(const ::fidl::DecodedMessage<Controller::StartResponse>& _msg);
+ static void StopRequest(const ::fidl::DecodedMessage<Controller::StopRequest>& _msg);
+ static void StopResponse(const ::fidl::DecodedMessage<Controller::StopResponse>& _msg);
+ };
+};
+
+constexpr uint16_t API_VERSION = 0u;
+
+} // namespace insntrace
+} // namespace cpu
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Allocation> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Allocation>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Allocation, mode) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Allocation, num_traces) == 2);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Allocation) == ::llcpp::fuchsia::hardware::cpu::insntrace::Allocation::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response) == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Terminate_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response) == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_ReleaseThreadBuffer_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response) == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_Initialize_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response) == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AssignThreadBuffer_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::BufferState> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::BufferState>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferState, capture_end) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferState) == ::llcpp::fuchsia::hardware::cpu::insntrace::BufferState::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response, descriptor) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response) == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::Controller_AllocateBuffer_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::AddressRange> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::AddressRange>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::AddressRange, start) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::AddressRange, end) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::AddressRange) == ::llcpp::fuchsia::hardware::cpu::insntrace::AddressRange::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig, num_chunks) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig, chunk_order) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig, is_circular) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig, ctl) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig, address_space_match) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig, address_range_0) == 32);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig, address_range_1) == 48);
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig) == ::llcpp::fuchsia::hardware::cpu::insntrace::BufferConfig::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeRequest)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeRequest, allocation) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::InitializeResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::TerminateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::TerminateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::TerminateResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::TerminateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::TerminateResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetAllocationResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetAllocationResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetAllocationResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetAllocationResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetAllocationResponse, allocation) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferRequest)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferRequest, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AllocateBufferResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferRequest)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferRequest, descriptor) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferRequest, thread) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::AssignThreadBufferResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferRequest)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferRequest, descriptor) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferRequest, thread) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::ReleaseThreadBufferResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigRequest)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigRequest, descriptor) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferConfigResponse, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateRequest)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateRequest, descriptor) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetBufferStateResponse, state) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleRequest)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleRequest, descriptor) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleRequest, chunk_num) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleResponse)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::GetChunkHandleResponse, buffer) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::FreeBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::cpu::insntrace::Controller::FreeBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::FreeBufferRequest)
+ == ::llcpp::fuchsia::hardware::cpu::insntrace::Controller::FreeBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::cpu::insntrace::Controller::FreeBufferRequest, descriptor) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-display/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-display/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..7e70414
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-display/gen/llcpp/fidl.cc
@@ -0,0 +1,3740 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/display/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace display {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kProvider_OpenVirtconController_Ordinal = 0x7522c7b300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProvider_OpenVirtconController_GenOrdinal = 0x7163a23d838e6fb6lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ProviderOpenVirtconControllerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ProviderOpenVirtconControllerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProvider_OpenController_Ordinal = 0x69d407d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProvider_OpenController_GenOrdinal = 0x54b5aa00a47ab0b3lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ProviderOpenControllerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ProviderOpenControllerResponseTable;
+
+} // namespace
+template <>
+Provider::ResultOf::OpenVirtconController_Impl<Provider::OpenVirtconControllerResponse>::OpenVirtconController_Impl(::zx::unowned_channel _client_end, ::zx::channel device, ::zx::channel controller) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenVirtconControllerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, OpenVirtconControllerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OpenVirtconControllerRequest*>(_write_bytes);
+ _request.device = std::move(device);
+ _request.controller = std::move(controller);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OpenVirtconControllerRequest));
+ ::fidl::DecodedMessage<OpenVirtconControllerRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Provider::InPlace::OpenVirtconController(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Provider::ResultOf::OpenVirtconController Provider::SyncClient::OpenVirtconController(::zx::channel device, ::zx::channel controller) {
+ return ResultOf::OpenVirtconController(::zx::unowned_channel(this->channel_), std::move(device), std::move(controller));
+}
+
+Provider::ResultOf::OpenVirtconController Provider::Call::OpenVirtconController(::zx::unowned_channel _client_end, ::zx::channel device, ::zx::channel controller) {
+ return ResultOf::OpenVirtconController(std::move(_client_end), std::move(device), std::move(controller));
+}
+
+template <>
+Provider::UnownedResultOf::OpenVirtconController_Impl<Provider::OpenVirtconControllerResponse>::OpenVirtconController_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < OpenVirtconControllerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<OpenVirtconControllerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, OpenVirtconControllerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OpenVirtconControllerRequest*>(_request_buffer.data());
+ _request.device = std::move(device);
+ _request.controller = std::move(controller);
+ _request_buffer.set_actual(sizeof(OpenVirtconControllerRequest));
+ ::fidl::DecodedMessage<OpenVirtconControllerRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Provider::InPlace::OpenVirtconController(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Provider::UnownedResultOf::OpenVirtconController Provider::SyncClient::OpenVirtconController(::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenVirtconController(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(device), std::move(controller), std::move(_response_buffer));
+}
+
+Provider::UnownedResultOf::OpenVirtconController Provider::Call::OpenVirtconController(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenVirtconController(std::move(_client_end), std::move(_request_buffer), std::move(device), std::move(controller), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Provider::OpenVirtconControllerResponse> Provider::InPlace::OpenVirtconController(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenVirtconControllerRequest> params, ::fidl::BytePart response_buffer) {
+ Provider::SetTransactionHeaderFor::OpenVirtconControllerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Provider::OpenVirtconControllerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<OpenVirtconControllerRequest, OpenVirtconControllerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Provider::OpenVirtconControllerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Provider::ResultOf::OpenController_Impl<Provider::OpenControllerResponse>::OpenController_Impl(::zx::unowned_channel _client_end, ::zx::channel device, ::zx::channel controller) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenControllerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, OpenControllerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OpenControllerRequest*>(_write_bytes);
+ _request.device = std::move(device);
+ _request.controller = std::move(controller);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OpenControllerRequest));
+ ::fidl::DecodedMessage<OpenControllerRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Provider::InPlace::OpenController(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Provider::ResultOf::OpenController Provider::SyncClient::OpenController(::zx::channel device, ::zx::channel controller) {
+ return ResultOf::OpenController(::zx::unowned_channel(this->channel_), std::move(device), std::move(controller));
+}
+
+Provider::ResultOf::OpenController Provider::Call::OpenController(::zx::unowned_channel _client_end, ::zx::channel device, ::zx::channel controller) {
+ return ResultOf::OpenController(std::move(_client_end), std::move(device), std::move(controller));
+}
+
+template <>
+Provider::UnownedResultOf::OpenController_Impl<Provider::OpenControllerResponse>::OpenController_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < OpenControllerRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<OpenControllerResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, OpenControllerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OpenControllerRequest*>(_request_buffer.data());
+ _request.device = std::move(device);
+ _request.controller = std::move(controller);
+ _request_buffer.set_actual(sizeof(OpenControllerRequest));
+ ::fidl::DecodedMessage<OpenControllerRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Provider::InPlace::OpenController(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Provider::UnownedResultOf::OpenController Provider::SyncClient::OpenController(::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenController(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(device), std::move(controller), std::move(_response_buffer));
+}
+
+Provider::UnownedResultOf::OpenController Provider::Call::OpenController(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenController(std::move(_client_end), std::move(_request_buffer), std::move(device), std::move(controller), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Provider::OpenControllerResponse> Provider::InPlace::OpenController(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenControllerRequest> params, ::fidl::BytePart response_buffer) {
+ Provider::SetTransactionHeaderFor::OpenControllerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Provider::OpenControllerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<OpenControllerRequest, OpenControllerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Provider::OpenControllerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Provider::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kProvider_OpenVirtconController_Ordinal:
+ case kProvider_OpenVirtconController_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenVirtconControllerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OpenVirtconController(std::move(message->device), std::move(message->controller),
+ Interface::OpenVirtconControllerCompleter::Sync(txn));
+ return true;
+ }
+ case kProvider_OpenController_Ordinal:
+ case kProvider_OpenController_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenControllerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OpenController(std::move(message->device), std::move(message->controller),
+ Interface::OpenControllerCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Provider::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Provider::Interface::OpenVirtconControllerCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenVirtconControllerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<OpenVirtconControllerResponse*>(_write_bytes);
+ Provider::SetTransactionHeaderFor::OpenVirtconControllerResponse(
+ ::fidl::DecodedMessage<OpenVirtconControllerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenVirtconControllerResponse::PrimarySize,
+ OpenVirtconControllerResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(OpenVirtconControllerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<OpenVirtconControllerResponse>(std::move(_response_bytes)));
+}
+
+void Provider::Interface::OpenVirtconControllerCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < OpenVirtconControllerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<OpenVirtconControllerResponse*>(_buffer.data());
+ Provider::SetTransactionHeaderFor::OpenVirtconControllerResponse(
+ ::fidl::DecodedMessage<OpenVirtconControllerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenVirtconControllerResponse::PrimarySize,
+ OpenVirtconControllerResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(OpenVirtconControllerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<OpenVirtconControllerResponse>(std::move(_buffer)));
+}
+
+void Provider::Interface::OpenVirtconControllerCompleterBase::Reply(::fidl::DecodedMessage<OpenVirtconControllerResponse> params) {
+ Provider::SetTransactionHeaderFor::OpenVirtconControllerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Provider::Interface::OpenControllerCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenControllerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<OpenControllerResponse*>(_write_bytes);
+ Provider::SetTransactionHeaderFor::OpenControllerResponse(
+ ::fidl::DecodedMessage<OpenControllerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenControllerResponse::PrimarySize,
+ OpenControllerResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(OpenControllerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<OpenControllerResponse>(std::move(_response_bytes)));
+}
+
+void Provider::Interface::OpenControllerCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < OpenControllerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<OpenControllerResponse*>(_buffer.data());
+ Provider::SetTransactionHeaderFor::OpenControllerResponse(
+ ::fidl::DecodedMessage<OpenControllerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenControllerResponse::PrimarySize,
+ OpenControllerResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(OpenControllerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<OpenControllerResponse>(std::move(_buffer)));
+}
+
+void Provider::Interface::OpenControllerCompleterBase::Reply(::fidl::DecodedMessage<OpenControllerResponse> params) {
+ Provider::SetTransactionHeaderFor::OpenControllerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Provider::SetTransactionHeaderFor::OpenVirtconControllerRequest(const ::fidl::DecodedMessage<Provider::OpenVirtconControllerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_OpenVirtconController_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Provider::SetTransactionHeaderFor::OpenVirtconControllerResponse(const ::fidl::DecodedMessage<Provider::OpenVirtconControllerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_OpenVirtconController_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Provider::SetTransactionHeaderFor::OpenControllerRequest(const ::fidl::DecodedMessage<Provider::OpenControllerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_OpenController_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Provider::SetTransactionHeaderFor::OpenControllerResponse(const ::fidl::DecodedMessage<Provider::OpenControllerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_OpenController_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::hardware::display::Controller_StartCapture_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_StartCapture_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_StartCapture_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_StartCapture_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_ReleaseCapture_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_ReleaseCapture_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_ReleaseCapture_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_IsCaptureSupported_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_IsCaptureSupported_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_IsCaptureSupported_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_ImportImageForCapture_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_ImportImageForCapture_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_ImportImageForCapture_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kController_DisplaysChanged_Ordinal = 0x30f5452200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_DisplaysChanged_GenOrdinal = 0x848efe931ddb1c6lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerDisplaysChangedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerDisplaysChangedEventTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportVmoImage_Ordinal = 0x420a4b7000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportVmoImage_GenOrdinal = 0x7cab4d73f9f1893clu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportVmoImageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportVmoImageResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportImage_Ordinal = 0x18d6e53b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportImage_GenOrdinal = 0x1be9cd6562de6db5lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportImageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportImageResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseImage_Ordinal = 0x3abc075800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseImage_GenOrdinal = 0x63a7d0a6b107bd11lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseImageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseImageResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportEvent_Ordinal = 0x7d2447aa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportEvent_GenOrdinal = 0x402289f13944e6d7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseEvent_Ordinal = 0x4379630400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseEvent_GenOrdinal = 0x657e4eab9a8e23a1lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_CreateLayer_Ordinal = 0x7f56932400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_CreateLayer_GenOrdinal = 0x468d06aadd139295lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerCreateLayerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerCreateLayerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_DestroyLayer_Ordinal = 0x2abc04b100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_DestroyLayer_GenOrdinal = 0x6b42dce004859fe5lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerDestroyLayerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerDestroyLayerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetDisplayMode_Ordinal = 0x584c92ab00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetDisplayMode_GenOrdinal = 0x55a035e7a881c48dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayModeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetDisplayColorConversion_Ordinal = 0x71cb370500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetDisplayColorConversion_GenOrdinal = 0x3d3548d04caf79b7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayColorConversionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayColorConversionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetDisplayLayers_Ordinal = 0x9bebf8600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetDisplayLayers_GenOrdinal = 0x47e92da1f9702675lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayLayersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayLayersResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerPrimaryConfig_Ordinal = 0x3673de6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerPrimaryConfig_GenOrdinal = 0x10bc9fc5d61f5c94lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerPrimaryPosition_Ordinal = 0x6bd4fbc600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerPrimaryPosition_GenOrdinal = 0x735faf29ee889cdclu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryPositionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryPositionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerPrimaryAlpha_Ordinal = 0x5a79ec9200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerPrimaryAlpha_GenOrdinal = 0x1b81604b1a9b6576lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryAlphaRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryAlphaResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerCursorConfig_Ordinal = 0x74020b200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerCursorConfig_GenOrdinal = 0x2fddfd240f9e7764lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerCursorConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerCursorConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerCursorPosition_Ordinal = 0x2f36e7b000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerCursorPosition_GenOrdinal = 0x147c1526ac3ad9c5lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerCursorPositionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerCursorPositionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerColorConfig_Ordinal = 0x21cc7c8800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerColorConfig_GenOrdinal = 0x19cb6da071d515calu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerColorConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerColorConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerImage_Ordinal = 0x1ecab8800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetLayerImage_GenOrdinal = 0x7c71f66253182fb9lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerImageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerImageResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_CheckConfig_Ordinal = 0x160ce58b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_CheckConfig_GenOrdinal = 0x586ca589eaf66e11lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerCheckConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerCheckConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ApplyConfig_Ordinal = 0x572081a200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ApplyConfig_GenOrdinal = 0x65b30a10604984f7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerApplyConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerApplyConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_EnableVsync_Ordinal = 0x2be2db1300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_EnableVsync_GenOrdinal = 0x5d517bdbc05d434elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerEnableVsyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerEnableVsyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Vsync_Ordinal = 0x71fcce9000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Vsync_GenOrdinal = 0x5813c85bf6f9d5f5lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerVsyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerVsyncEventTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetVirtconMode_Ordinal = 0x49c4520700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetVirtconMode_GenOrdinal = 0x7c8d1b102e72182clu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetVirtconModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetVirtconModeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ClientOwnershipChange_Ordinal = 0x4360b92e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ClientOwnershipChange_GenOrdinal = 0x41b1af32fb2f7362lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerClientOwnershipChangeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerClientOwnershipChangeEventTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportBufferCollection_Ordinal = 0x605b9d0d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportBufferCollection_GenOrdinal = 0x1cdf9cc2e60832d1lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportBufferCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportBufferCollectionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseBufferCollection_Ordinal = 0x52f8b58400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseBufferCollection_GenOrdinal = 0x4527c480391b6c83lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseBufferCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseBufferCollectionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_SetBufferCollectionConstraints_Ordinal = 0x78b51dd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_SetBufferCollectionConstraints_GenOrdinal = 0x3b78d75d2d21b451lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetBufferCollectionConstraintsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetBufferCollectionConstraintsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetSingleBufferFramebuffer_Ordinal = 0x2ecce54500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetSingleBufferFramebuffer_GenOrdinal = 0x65cd908c2c03b49dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerGetSingleBufferFramebufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerGetSingleBufferFramebufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_IsCaptureSupported_Ordinal = 0x6dfc193a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_IsCaptureSupported_GenOrdinal = 0x1cd2541e93a17760lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerIsCaptureSupportedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerIsCaptureSupportedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportImageForCapture_Ordinal = 0x3150d1a200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ImportImageForCapture_GenOrdinal = 0x2a595fbc2df7f9eblu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportImageForCaptureRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportImageForCaptureResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_StartCapture_Ordinal = 0x5436d93300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_StartCapture_GenOrdinal = 0x7d4ccf55f0259266lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerStartCaptureRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerStartCaptureResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseCapture_Ordinal = 0x7f1785f000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_ReleaseCapture_GenOrdinal = 0x3c5dbe1d114a5752lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseCaptureRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseCaptureResponseTable;
+
+} // namespace
+template <>
+Controller::ResultOf::ImportVmoImage_Impl<Controller::ImportVmoImageResponse>::ImportVmoImage_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportVmoImageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ImportVmoImageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportVmoImageRequest*>(_write_bytes);
+ _request.image_config = std::move(image_config);
+ _request.vmo = std::move(vmo);
+ _request.offset = std::move(offset);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ImportVmoImageRequest));
+ ::fidl::DecodedMessage<ImportVmoImageRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::ImportVmoImage(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::ImportVmoImage Controller::SyncClient::ImportVmoImage(::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset) {
+ return ResultOf::ImportVmoImage(::zx::unowned_channel(this->channel_), std::move(image_config), std::move(vmo), std::move(offset));
+}
+
+Controller::ResultOf::ImportVmoImage Controller::Call::ImportVmoImage(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset) {
+ return ResultOf::ImportVmoImage(std::move(_client_end), std::move(image_config), std::move(vmo), std::move(offset));
+}
+
+template <>
+Controller::UnownedResultOf::ImportVmoImage_Impl<Controller::ImportVmoImageResponse>::ImportVmoImage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ImportVmoImageRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ImportVmoImageResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ImportVmoImageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportVmoImageRequest*>(_request_buffer.data());
+ _request.image_config = std::move(image_config);
+ _request.vmo = std::move(vmo);
+ _request.offset = std::move(offset);
+ _request_buffer.set_actual(sizeof(ImportVmoImageRequest));
+ ::fidl::DecodedMessage<ImportVmoImageRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::ImportVmoImage(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::ImportVmoImage Controller::SyncClient::ImportVmoImage(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ImportVmoImage(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(image_config), std::move(vmo), std::move(offset), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::ImportVmoImage Controller::Call::ImportVmoImage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ImportVmoImage(std::move(_client_end), std::move(_request_buffer), std::move(image_config), std::move(vmo), std::move(offset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ImportVmoImageResponse> Controller::InPlace::ImportVmoImage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportVmoImageRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::ImportVmoImageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ImportVmoImageResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ImportVmoImageRequest, ImportVmoImageResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ImportVmoImageResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::ImportImage_Impl<Controller::ImportImageResponse>::ImportImage_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportImageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ImportImageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportImageRequest*>(_write_bytes);
+ _request.image_config = std::move(image_config);
+ _request.collection_id = std::move(collection_id);
+ _request.index = std::move(index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ImportImageRequest));
+ ::fidl::DecodedMessage<ImportImageRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::ImportImage(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::ImportImage Controller::SyncClient::ImportImage(::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index) {
+ return ResultOf::ImportImage(::zx::unowned_channel(this->channel_), std::move(image_config), std::move(collection_id), std::move(index));
+}
+
+Controller::ResultOf::ImportImage Controller::Call::ImportImage(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index) {
+ return ResultOf::ImportImage(std::move(_client_end), std::move(image_config), std::move(collection_id), std::move(index));
+}
+
+template <>
+Controller::UnownedResultOf::ImportImage_Impl<Controller::ImportImageResponse>::ImportImage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ImportImageRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ImportImageResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ImportImageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportImageRequest*>(_request_buffer.data());
+ _request.image_config = std::move(image_config);
+ _request.collection_id = std::move(collection_id);
+ _request.index = std::move(index);
+ _request_buffer.set_actual(sizeof(ImportImageRequest));
+ ::fidl::DecodedMessage<ImportImageRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::ImportImage(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::ImportImage Controller::SyncClient::ImportImage(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ImportImage(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(image_config), std::move(collection_id), std::move(index), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::ImportImage Controller::Call::ImportImage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ImportImage(std::move(_client_end), std::move(_request_buffer), std::move(image_config), std::move(collection_id), std::move(index), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ImportImageResponse> Controller::InPlace::ImportImage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportImageRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::ImportImageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ImportImageResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ImportImageRequest, ImportImageResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ImportImageResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Controller::ResultOf::ReleaseImage_Impl::ReleaseImage_Impl(::zx::unowned_channel _client_end, uint64_t image_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseImageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReleaseImageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseImageRequest*>(_write_bytes);
+ _request.image_id = std::move(image_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReleaseImageRequest));
+ ::fidl::DecodedMessage<ReleaseImageRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::ReleaseImage(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::ReleaseImage Controller::SyncClient::ReleaseImage(uint64_t image_id) {
+ return ResultOf::ReleaseImage(::zx::unowned_channel(this->channel_), std::move(image_id));
+}
+
+Controller::ResultOf::ReleaseImage Controller::Call::ReleaseImage(::zx::unowned_channel _client_end, uint64_t image_id) {
+ return ResultOf::ReleaseImage(std::move(_client_end), std::move(image_id));
+}
+
+
+Controller::UnownedResultOf::ReleaseImage_Impl::ReleaseImage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t image_id) {
+ if (_request_buffer.capacity() < ReleaseImageRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReleaseImageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseImageRequest*>(_request_buffer.data());
+ _request.image_id = std::move(image_id);
+ _request_buffer.set_actual(sizeof(ReleaseImageRequest));
+ ::fidl::DecodedMessage<ReleaseImageRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::ReleaseImage(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::ReleaseImage Controller::SyncClient::ReleaseImage(::fidl::BytePart _request_buffer, uint64_t image_id) {
+ return UnownedResultOf::ReleaseImage(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(image_id));
+}
+
+Controller::UnownedResultOf::ReleaseImage Controller::Call::ReleaseImage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t image_id) {
+ return UnownedResultOf::ReleaseImage(std::move(_client_end), std::move(_request_buffer), std::move(image_id));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::ReleaseImage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseImageRequest> params) {
+ Controller::SetTransactionHeaderFor::ReleaseImageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::ImportEvent_Impl::ImportEvent_Impl(::zx::unowned_channel _client_end, ::zx::event event, uint64_t id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ImportEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportEventRequest*>(_write_bytes);
+ _request.event = std::move(event);
+ _request.id = std::move(id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ImportEventRequest));
+ ::fidl::DecodedMessage<ImportEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::ImportEvent(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::ImportEvent Controller::SyncClient::ImportEvent(::zx::event event, uint64_t id) {
+ return ResultOf::ImportEvent(::zx::unowned_channel(this->channel_), std::move(event), std::move(id));
+}
+
+Controller::ResultOf::ImportEvent Controller::Call::ImportEvent(::zx::unowned_channel _client_end, ::zx::event event, uint64_t id) {
+ return ResultOf::ImportEvent(std::move(_client_end), std::move(event), std::move(id));
+}
+
+
+Controller::UnownedResultOf::ImportEvent_Impl::ImportEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::event event, uint64_t id) {
+ if (_request_buffer.capacity() < ImportEventRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ImportEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportEventRequest*>(_request_buffer.data());
+ _request.event = std::move(event);
+ _request.id = std::move(id);
+ _request_buffer.set_actual(sizeof(ImportEventRequest));
+ ::fidl::DecodedMessage<ImportEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::ImportEvent(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::ImportEvent Controller::SyncClient::ImportEvent(::fidl::BytePart _request_buffer, ::zx::event event, uint64_t id) {
+ return UnownedResultOf::ImportEvent(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(event), std::move(id));
+}
+
+Controller::UnownedResultOf::ImportEvent Controller::Call::ImportEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::event event, uint64_t id) {
+ return UnownedResultOf::ImportEvent(std::move(_client_end), std::move(_request_buffer), std::move(event), std::move(id));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::ImportEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportEventRequest> params) {
+ Controller::SetTransactionHeaderFor::ImportEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::ReleaseEvent_Impl::ReleaseEvent_Impl(::zx::unowned_channel _client_end, uint64_t id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReleaseEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseEventRequest*>(_write_bytes);
+ _request.id = std::move(id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReleaseEventRequest));
+ ::fidl::DecodedMessage<ReleaseEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::ReleaseEvent(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::ReleaseEvent Controller::SyncClient::ReleaseEvent(uint64_t id) {
+ return ResultOf::ReleaseEvent(::zx::unowned_channel(this->channel_), std::move(id));
+}
+
+Controller::ResultOf::ReleaseEvent Controller::Call::ReleaseEvent(::zx::unowned_channel _client_end, uint64_t id) {
+ return ResultOf::ReleaseEvent(std::move(_client_end), std::move(id));
+}
+
+
+Controller::UnownedResultOf::ReleaseEvent_Impl::ReleaseEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t id) {
+ if (_request_buffer.capacity() < ReleaseEventRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReleaseEventRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseEventRequest*>(_request_buffer.data());
+ _request.id = std::move(id);
+ _request_buffer.set_actual(sizeof(ReleaseEventRequest));
+ ::fidl::DecodedMessage<ReleaseEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::ReleaseEvent(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::ReleaseEvent Controller::SyncClient::ReleaseEvent(::fidl::BytePart _request_buffer, uint64_t id) {
+ return UnownedResultOf::ReleaseEvent(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(id));
+}
+
+Controller::UnownedResultOf::ReleaseEvent Controller::Call::ReleaseEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t id) {
+ return UnownedResultOf::ReleaseEvent(std::move(_client_end), std::move(_request_buffer), std::move(id));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::ReleaseEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseEventRequest> params) {
+ Controller::SetTransactionHeaderFor::ReleaseEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Controller::ResultOf::CreateLayer_Impl<Controller::CreateLayerResponse>::CreateLayer_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLayerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CreateLayerRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLayerRequest));
+ ::fidl::DecodedMessage<CreateLayerRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::CreateLayer(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::CreateLayer Controller::SyncClient::CreateLayer() {
+ return ResultOf::CreateLayer(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::CreateLayer Controller::Call::CreateLayer(::zx::unowned_channel _client_end) {
+ return ResultOf::CreateLayer(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::CreateLayer_Impl<Controller::CreateLayerResponse>::CreateLayer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CreateLayerRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CreateLayerRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CreateLayerRequest));
+ ::fidl::DecodedMessage<CreateLayerRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::CreateLayer(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::CreateLayer Controller::SyncClient::CreateLayer(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLayer(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::CreateLayer Controller::Call::CreateLayer(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateLayer(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::CreateLayerResponse> Controller::InPlace::CreateLayer(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CreateLayerRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CreateLayerRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::CreateLayerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::CreateLayerResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CreateLayerRequest, CreateLayerResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::CreateLayerResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Controller::ResultOf::DestroyLayer_Impl::DestroyLayer_Impl(::zx::unowned_channel _client_end, uint64_t layer_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DestroyLayerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DestroyLayerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DestroyLayerRequest*>(_write_bytes);
+ _request.layer_id = std::move(layer_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DestroyLayerRequest));
+ ::fidl::DecodedMessage<DestroyLayerRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::DestroyLayer(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::DestroyLayer Controller::SyncClient::DestroyLayer(uint64_t layer_id) {
+ return ResultOf::DestroyLayer(::zx::unowned_channel(this->channel_), std::move(layer_id));
+}
+
+Controller::ResultOf::DestroyLayer Controller::Call::DestroyLayer(::zx::unowned_channel _client_end, uint64_t layer_id) {
+ return ResultOf::DestroyLayer(std::move(_client_end), std::move(layer_id));
+}
+
+
+Controller::UnownedResultOf::DestroyLayer_Impl::DestroyLayer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id) {
+ if (_request_buffer.capacity() < DestroyLayerRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, DestroyLayerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DestroyLayerRequest*>(_request_buffer.data());
+ _request.layer_id = std::move(layer_id);
+ _request_buffer.set_actual(sizeof(DestroyLayerRequest));
+ ::fidl::DecodedMessage<DestroyLayerRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::DestroyLayer(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::DestroyLayer Controller::SyncClient::DestroyLayer(::fidl::BytePart _request_buffer, uint64_t layer_id) {
+ return UnownedResultOf::DestroyLayer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layer_id));
+}
+
+Controller::UnownedResultOf::DestroyLayer Controller::Call::DestroyLayer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id) {
+ return UnownedResultOf::DestroyLayer(std::move(_client_end), std::move(_request_buffer), std::move(layer_id));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::DestroyLayer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DestroyLayerRequest> params) {
+ Controller::SetTransactionHeaderFor::DestroyLayerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetDisplayMode_Impl::SetDisplayMode_Impl(::zx::unowned_channel _client_end, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetDisplayModeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetDisplayModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetDisplayModeRequest*>(_write_bytes);
+ _request.display_id = std::move(display_id);
+ _request.mode = std::move(mode);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetDisplayModeRequest));
+ ::fidl::DecodedMessage<SetDisplayModeRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetDisplayMode(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetDisplayMode Controller::SyncClient::SetDisplayMode(uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode) {
+ return ResultOf::SetDisplayMode(::zx::unowned_channel(this->channel_), std::move(display_id), std::move(mode));
+}
+
+Controller::ResultOf::SetDisplayMode Controller::Call::SetDisplayMode(::zx::unowned_channel _client_end, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode) {
+ return ResultOf::SetDisplayMode(std::move(_client_end), std::move(display_id), std::move(mode));
+}
+
+
+Controller::UnownedResultOf::SetDisplayMode_Impl::SetDisplayMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode) {
+ if (_request_buffer.capacity() < SetDisplayModeRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetDisplayModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetDisplayModeRequest*>(_request_buffer.data());
+ _request.display_id = std::move(display_id);
+ _request.mode = std::move(mode);
+ _request_buffer.set_actual(sizeof(SetDisplayModeRequest));
+ ::fidl::DecodedMessage<SetDisplayModeRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetDisplayMode(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetDisplayMode Controller::SyncClient::SetDisplayMode(::fidl::BytePart _request_buffer, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode) {
+ return UnownedResultOf::SetDisplayMode(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(display_id), std::move(mode));
+}
+
+Controller::UnownedResultOf::SetDisplayMode Controller::Call::SetDisplayMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode) {
+ return UnownedResultOf::SetDisplayMode(std::move(_client_end), std::move(_request_buffer), std::move(display_id), std::move(mode));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetDisplayMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDisplayModeRequest> params) {
+ Controller::SetTransactionHeaderFor::SetDisplayModeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetDisplayColorConversion_Impl::SetDisplayColorConversion_Impl(::zx::unowned_channel _client_end, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetDisplayColorConversionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetDisplayColorConversionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetDisplayColorConversionRequest*>(_write_bytes);
+ _request.display_id = std::move(display_id);
+ _request.preoffsets = std::move(preoffsets);
+ _request.coefficients = std::move(coefficients);
+ _request.postoffsets = std::move(postoffsets);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetDisplayColorConversionRequest));
+ ::fidl::DecodedMessage<SetDisplayColorConversionRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetDisplayColorConversion(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetDisplayColorConversion Controller::SyncClient::SetDisplayColorConversion(uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets) {
+ return ResultOf::SetDisplayColorConversion(::zx::unowned_channel(this->channel_), std::move(display_id), std::move(preoffsets), std::move(coefficients), std::move(postoffsets));
+}
+
+Controller::ResultOf::SetDisplayColorConversion Controller::Call::SetDisplayColorConversion(::zx::unowned_channel _client_end, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets) {
+ return ResultOf::SetDisplayColorConversion(std::move(_client_end), std::move(display_id), std::move(preoffsets), std::move(coefficients), std::move(postoffsets));
+}
+
+
+Controller::UnownedResultOf::SetDisplayColorConversion_Impl::SetDisplayColorConversion_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets) {
+ if (_request_buffer.capacity() < SetDisplayColorConversionRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetDisplayColorConversionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetDisplayColorConversionRequest*>(_request_buffer.data());
+ _request.display_id = std::move(display_id);
+ _request.preoffsets = std::move(preoffsets);
+ _request.coefficients = std::move(coefficients);
+ _request.postoffsets = std::move(postoffsets);
+ _request_buffer.set_actual(sizeof(SetDisplayColorConversionRequest));
+ ::fidl::DecodedMessage<SetDisplayColorConversionRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetDisplayColorConversion(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetDisplayColorConversion Controller::SyncClient::SetDisplayColorConversion(::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets) {
+ return UnownedResultOf::SetDisplayColorConversion(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(display_id), std::move(preoffsets), std::move(coefficients), std::move(postoffsets));
+}
+
+Controller::UnownedResultOf::SetDisplayColorConversion Controller::Call::SetDisplayColorConversion(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets) {
+ return UnownedResultOf::SetDisplayColorConversion(std::move(_client_end), std::move(_request_buffer), std::move(display_id), std::move(preoffsets), std::move(coefficients), std::move(postoffsets));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetDisplayColorConversion(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDisplayColorConversionRequest> params) {
+ Controller::SetTransactionHeaderFor::SetDisplayColorConversionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetDisplayLayers_Impl::SetDisplayLayers_Impl(::zx::unowned_channel _client_end, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetDisplayLayersRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetDisplayLayersRequest _request = {};
+ _request.display_id = std::move(display_id);
+ _request.layer_ids = std::move(layer_ids);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetDisplayLayersRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Controller::InPlace::SetDisplayLayers(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetDisplayLayers Controller::SyncClient::SetDisplayLayers(uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids) {
+ return ResultOf::SetDisplayLayers(::zx::unowned_channel(this->channel_), std::move(display_id), std::move(layer_ids));
+}
+
+Controller::ResultOf::SetDisplayLayers Controller::Call::SetDisplayLayers(::zx::unowned_channel _client_end, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids) {
+ return ResultOf::SetDisplayLayers(std::move(_client_end), std::move(display_id), std::move(layer_ids));
+}
+
+
+Controller::UnownedResultOf::SetDisplayLayers_Impl::SetDisplayLayers_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids) {
+ if (_request_buffer.capacity() < SetDisplayLayersRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ SetDisplayLayersRequest _request = {};
+ _request.display_id = std::move(display_id);
+ _request.layer_ids = std::move(layer_ids);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetDisplayLayersRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Controller::InPlace::SetDisplayLayers(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetDisplayLayers Controller::SyncClient::SetDisplayLayers(::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids) {
+ return UnownedResultOf::SetDisplayLayers(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(display_id), std::move(layer_ids));
+}
+
+Controller::UnownedResultOf::SetDisplayLayers Controller::Call::SetDisplayLayers(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids) {
+ return UnownedResultOf::SetDisplayLayers(std::move(_client_end), std::move(_request_buffer), std::move(display_id), std::move(layer_ids));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetDisplayLayers(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDisplayLayersRequest> params) {
+ Controller::SetTransactionHeaderFor::SetDisplayLayersRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetLayerPrimaryConfig_Impl::SetLayerPrimaryConfig_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetLayerPrimaryConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetLayerPrimaryConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerPrimaryConfigRequest*>(_write_bytes);
+ _request.layer_id = std::move(layer_id);
+ _request.image_config = std::move(image_config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetLayerPrimaryConfigRequest));
+ ::fidl::DecodedMessage<SetLayerPrimaryConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetLayerPrimaryConfig(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetLayerPrimaryConfig Controller::SyncClient::SetLayerPrimaryConfig(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ return ResultOf::SetLayerPrimaryConfig(::zx::unowned_channel(this->channel_), std::move(layer_id), std::move(image_config));
+}
+
+Controller::ResultOf::SetLayerPrimaryConfig Controller::Call::SetLayerPrimaryConfig(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ return ResultOf::SetLayerPrimaryConfig(std::move(_client_end), std::move(layer_id), std::move(image_config));
+}
+
+
+Controller::UnownedResultOf::SetLayerPrimaryConfig_Impl::SetLayerPrimaryConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ if (_request_buffer.capacity() < SetLayerPrimaryConfigRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetLayerPrimaryConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerPrimaryConfigRequest*>(_request_buffer.data());
+ _request.layer_id = std::move(layer_id);
+ _request.image_config = std::move(image_config);
+ _request_buffer.set_actual(sizeof(SetLayerPrimaryConfigRequest));
+ ::fidl::DecodedMessage<SetLayerPrimaryConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetLayerPrimaryConfig(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetLayerPrimaryConfig Controller::SyncClient::SetLayerPrimaryConfig(::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ return UnownedResultOf::SetLayerPrimaryConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layer_id), std::move(image_config));
+}
+
+Controller::UnownedResultOf::SetLayerPrimaryConfig Controller::Call::SetLayerPrimaryConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ return UnownedResultOf::SetLayerPrimaryConfig(std::move(_client_end), std::move(_request_buffer), std::move(layer_id), std::move(image_config));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetLayerPrimaryConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerPrimaryConfigRequest> params) {
+ Controller::SetTransactionHeaderFor::SetLayerPrimaryConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetLayerPrimaryPosition_Impl::SetLayerPrimaryPosition_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetLayerPrimaryPositionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetLayerPrimaryPositionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerPrimaryPositionRequest*>(_write_bytes);
+ _request.layer_id = std::move(layer_id);
+ _request.transform = std::move(transform);
+ _request.src_frame = std::move(src_frame);
+ _request.dest_frame = std::move(dest_frame);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetLayerPrimaryPositionRequest));
+ ::fidl::DecodedMessage<SetLayerPrimaryPositionRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetLayerPrimaryPosition(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetLayerPrimaryPosition Controller::SyncClient::SetLayerPrimaryPosition(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame) {
+ return ResultOf::SetLayerPrimaryPosition(::zx::unowned_channel(this->channel_), std::move(layer_id), std::move(transform), std::move(src_frame), std::move(dest_frame));
+}
+
+Controller::ResultOf::SetLayerPrimaryPosition Controller::Call::SetLayerPrimaryPosition(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame) {
+ return ResultOf::SetLayerPrimaryPosition(std::move(_client_end), std::move(layer_id), std::move(transform), std::move(src_frame), std::move(dest_frame));
+}
+
+
+Controller::UnownedResultOf::SetLayerPrimaryPosition_Impl::SetLayerPrimaryPosition_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame) {
+ if (_request_buffer.capacity() < SetLayerPrimaryPositionRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetLayerPrimaryPositionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerPrimaryPositionRequest*>(_request_buffer.data());
+ _request.layer_id = std::move(layer_id);
+ _request.transform = std::move(transform);
+ _request.src_frame = std::move(src_frame);
+ _request.dest_frame = std::move(dest_frame);
+ _request_buffer.set_actual(sizeof(SetLayerPrimaryPositionRequest));
+ ::fidl::DecodedMessage<SetLayerPrimaryPositionRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetLayerPrimaryPosition(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetLayerPrimaryPosition Controller::SyncClient::SetLayerPrimaryPosition(::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame) {
+ return UnownedResultOf::SetLayerPrimaryPosition(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layer_id), std::move(transform), std::move(src_frame), std::move(dest_frame));
+}
+
+Controller::UnownedResultOf::SetLayerPrimaryPosition Controller::Call::SetLayerPrimaryPosition(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame) {
+ return UnownedResultOf::SetLayerPrimaryPosition(std::move(_client_end), std::move(_request_buffer), std::move(layer_id), std::move(transform), std::move(src_frame), std::move(dest_frame));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetLayerPrimaryPosition(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerPrimaryPositionRequest> params) {
+ Controller::SetTransactionHeaderFor::SetLayerPrimaryPositionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetLayerPrimaryAlpha_Impl::SetLayerPrimaryAlpha_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetLayerPrimaryAlphaRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetLayerPrimaryAlphaRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerPrimaryAlphaRequest*>(_write_bytes);
+ _request.layer_id = std::move(layer_id);
+ _request.mode = std::move(mode);
+ _request.val = std::move(val);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetLayerPrimaryAlphaRequest));
+ ::fidl::DecodedMessage<SetLayerPrimaryAlphaRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetLayerPrimaryAlpha(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetLayerPrimaryAlpha Controller::SyncClient::SetLayerPrimaryAlpha(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val) {
+ return ResultOf::SetLayerPrimaryAlpha(::zx::unowned_channel(this->channel_), std::move(layer_id), std::move(mode), std::move(val));
+}
+
+Controller::ResultOf::SetLayerPrimaryAlpha Controller::Call::SetLayerPrimaryAlpha(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val) {
+ return ResultOf::SetLayerPrimaryAlpha(std::move(_client_end), std::move(layer_id), std::move(mode), std::move(val));
+}
+
+
+Controller::UnownedResultOf::SetLayerPrimaryAlpha_Impl::SetLayerPrimaryAlpha_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val) {
+ if (_request_buffer.capacity() < SetLayerPrimaryAlphaRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetLayerPrimaryAlphaRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerPrimaryAlphaRequest*>(_request_buffer.data());
+ _request.layer_id = std::move(layer_id);
+ _request.mode = std::move(mode);
+ _request.val = std::move(val);
+ _request_buffer.set_actual(sizeof(SetLayerPrimaryAlphaRequest));
+ ::fidl::DecodedMessage<SetLayerPrimaryAlphaRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetLayerPrimaryAlpha(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetLayerPrimaryAlpha Controller::SyncClient::SetLayerPrimaryAlpha(::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val) {
+ return UnownedResultOf::SetLayerPrimaryAlpha(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layer_id), std::move(mode), std::move(val));
+}
+
+Controller::UnownedResultOf::SetLayerPrimaryAlpha Controller::Call::SetLayerPrimaryAlpha(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val) {
+ return UnownedResultOf::SetLayerPrimaryAlpha(std::move(_client_end), std::move(_request_buffer), std::move(layer_id), std::move(mode), std::move(val));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetLayerPrimaryAlpha(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerPrimaryAlphaRequest> params) {
+ Controller::SetTransactionHeaderFor::SetLayerPrimaryAlphaRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetLayerCursorConfig_Impl::SetLayerCursorConfig_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetLayerCursorConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetLayerCursorConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerCursorConfigRequest*>(_write_bytes);
+ _request.layer_id = std::move(layer_id);
+ _request.image_config = std::move(image_config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetLayerCursorConfigRequest));
+ ::fidl::DecodedMessage<SetLayerCursorConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetLayerCursorConfig(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetLayerCursorConfig Controller::SyncClient::SetLayerCursorConfig(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ return ResultOf::SetLayerCursorConfig(::zx::unowned_channel(this->channel_), std::move(layer_id), std::move(image_config));
+}
+
+Controller::ResultOf::SetLayerCursorConfig Controller::Call::SetLayerCursorConfig(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ return ResultOf::SetLayerCursorConfig(std::move(_client_end), std::move(layer_id), std::move(image_config));
+}
+
+
+Controller::UnownedResultOf::SetLayerCursorConfig_Impl::SetLayerCursorConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ if (_request_buffer.capacity() < SetLayerCursorConfigRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetLayerCursorConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerCursorConfigRequest*>(_request_buffer.data());
+ _request.layer_id = std::move(layer_id);
+ _request.image_config = std::move(image_config);
+ _request_buffer.set_actual(sizeof(SetLayerCursorConfigRequest));
+ ::fidl::DecodedMessage<SetLayerCursorConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetLayerCursorConfig(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetLayerCursorConfig Controller::SyncClient::SetLayerCursorConfig(::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ return UnownedResultOf::SetLayerCursorConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layer_id), std::move(image_config));
+}
+
+Controller::UnownedResultOf::SetLayerCursorConfig Controller::Call::SetLayerCursorConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config) {
+ return UnownedResultOf::SetLayerCursorConfig(std::move(_client_end), std::move(_request_buffer), std::move(layer_id), std::move(image_config));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetLayerCursorConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerCursorConfigRequest> params) {
+ Controller::SetTransactionHeaderFor::SetLayerCursorConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetLayerCursorPosition_Impl::SetLayerCursorPosition_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, int32_t x, int32_t y) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetLayerCursorPositionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetLayerCursorPositionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerCursorPositionRequest*>(_write_bytes);
+ _request.layer_id = std::move(layer_id);
+ _request.x = std::move(x);
+ _request.y = std::move(y);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetLayerCursorPositionRequest));
+ ::fidl::DecodedMessage<SetLayerCursorPositionRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetLayerCursorPosition(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetLayerCursorPosition Controller::SyncClient::SetLayerCursorPosition(uint64_t layer_id, int32_t x, int32_t y) {
+ return ResultOf::SetLayerCursorPosition(::zx::unowned_channel(this->channel_), std::move(layer_id), std::move(x), std::move(y));
+}
+
+Controller::ResultOf::SetLayerCursorPosition Controller::Call::SetLayerCursorPosition(::zx::unowned_channel _client_end, uint64_t layer_id, int32_t x, int32_t y) {
+ return ResultOf::SetLayerCursorPosition(std::move(_client_end), std::move(layer_id), std::move(x), std::move(y));
+}
+
+
+Controller::UnownedResultOf::SetLayerCursorPosition_Impl::SetLayerCursorPosition_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, int32_t x, int32_t y) {
+ if (_request_buffer.capacity() < SetLayerCursorPositionRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetLayerCursorPositionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerCursorPositionRequest*>(_request_buffer.data());
+ _request.layer_id = std::move(layer_id);
+ _request.x = std::move(x);
+ _request.y = std::move(y);
+ _request_buffer.set_actual(sizeof(SetLayerCursorPositionRequest));
+ ::fidl::DecodedMessage<SetLayerCursorPositionRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetLayerCursorPosition(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetLayerCursorPosition Controller::SyncClient::SetLayerCursorPosition(::fidl::BytePart _request_buffer, uint64_t layer_id, int32_t x, int32_t y) {
+ return UnownedResultOf::SetLayerCursorPosition(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layer_id), std::move(x), std::move(y));
+}
+
+Controller::UnownedResultOf::SetLayerCursorPosition Controller::Call::SetLayerCursorPosition(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, int32_t x, int32_t y) {
+ return UnownedResultOf::SetLayerCursorPosition(std::move(_client_end), std::move(_request_buffer), std::move(layer_id), std::move(x), std::move(y));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetLayerCursorPosition(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerCursorPositionRequest> params) {
+ Controller::SetTransactionHeaderFor::SetLayerCursorPositionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetLayerColorConfig_Impl::SetLayerColorConfig_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetLayerColorConfigRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetLayerColorConfigRequest _request = {};
+ _request.layer_id = std::move(layer_id);
+ _request.pixel_format = std::move(pixel_format);
+ _request.color_bytes = std::move(color_bytes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetLayerColorConfigRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Controller::InPlace::SetLayerColorConfig(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetLayerColorConfig Controller::SyncClient::SetLayerColorConfig(uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes) {
+ return ResultOf::SetLayerColorConfig(::zx::unowned_channel(this->channel_), std::move(layer_id), std::move(pixel_format), std::move(color_bytes));
+}
+
+Controller::ResultOf::SetLayerColorConfig Controller::Call::SetLayerColorConfig(::zx::unowned_channel _client_end, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes) {
+ return ResultOf::SetLayerColorConfig(std::move(_client_end), std::move(layer_id), std::move(pixel_format), std::move(color_bytes));
+}
+
+
+Controller::UnownedResultOf::SetLayerColorConfig_Impl::SetLayerColorConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes) {
+ if (_request_buffer.capacity() < SetLayerColorConfigRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ SetLayerColorConfigRequest _request = {};
+ _request.layer_id = std::move(layer_id);
+ _request.pixel_format = std::move(pixel_format);
+ _request.color_bytes = std::move(color_bytes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetLayerColorConfigRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Controller::InPlace::SetLayerColorConfig(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetLayerColorConfig Controller::SyncClient::SetLayerColorConfig(::fidl::BytePart _request_buffer, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes) {
+ return UnownedResultOf::SetLayerColorConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layer_id), std::move(pixel_format), std::move(color_bytes));
+}
+
+Controller::UnownedResultOf::SetLayerColorConfig Controller::Call::SetLayerColorConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes) {
+ return UnownedResultOf::SetLayerColorConfig(std::move(_client_end), std::move(_request_buffer), std::move(layer_id), std::move(pixel_format), std::move(color_bytes));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetLayerColorConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerColorConfigRequest> params) {
+ Controller::SetTransactionHeaderFor::SetLayerColorConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetLayerImage_Impl::SetLayerImage_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetLayerImageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetLayerImageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerImageRequest*>(_write_bytes);
+ _request.layer_id = std::move(layer_id);
+ _request.image_id = std::move(image_id);
+ _request.wait_event_id = std::move(wait_event_id);
+ _request.signal_event_id = std::move(signal_event_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetLayerImageRequest));
+ ::fidl::DecodedMessage<SetLayerImageRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetLayerImage(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetLayerImage Controller::SyncClient::SetLayerImage(uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id) {
+ return ResultOf::SetLayerImage(::zx::unowned_channel(this->channel_), std::move(layer_id), std::move(image_id), std::move(wait_event_id), std::move(signal_event_id));
+}
+
+Controller::ResultOf::SetLayerImage Controller::Call::SetLayerImage(::zx::unowned_channel _client_end, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id) {
+ return ResultOf::SetLayerImage(std::move(_client_end), std::move(layer_id), std::move(image_id), std::move(wait_event_id), std::move(signal_event_id));
+}
+
+
+Controller::UnownedResultOf::SetLayerImage_Impl::SetLayerImage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id) {
+ if (_request_buffer.capacity() < SetLayerImageRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetLayerImageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetLayerImageRequest*>(_request_buffer.data());
+ _request.layer_id = std::move(layer_id);
+ _request.image_id = std::move(image_id);
+ _request.wait_event_id = std::move(wait_event_id);
+ _request.signal_event_id = std::move(signal_event_id);
+ _request_buffer.set_actual(sizeof(SetLayerImageRequest));
+ ::fidl::DecodedMessage<SetLayerImageRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetLayerImage(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetLayerImage Controller::SyncClient::SetLayerImage(::fidl::BytePart _request_buffer, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id) {
+ return UnownedResultOf::SetLayerImage(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layer_id), std::move(image_id), std::move(wait_event_id), std::move(signal_event_id));
+}
+
+Controller::UnownedResultOf::SetLayerImage Controller::Call::SetLayerImage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id) {
+ return UnownedResultOf::SetLayerImage(std::move(_client_end), std::move(_request_buffer), std::move(layer_id), std::move(image_id), std::move(wait_event_id), std::move(signal_event_id));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetLayerImage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerImageRequest> params) {
+ Controller::SetTransactionHeaderFor::SetLayerImageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Controller::ResultOf::CheckConfig_Impl<Controller::CheckConfigResponse>::CheckConfig_Impl(::zx::unowned_channel _client_end, bool discard) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CheckConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CheckConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CheckConfigRequest*>(_write_bytes);
+ _request.discard = std::move(discard);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CheckConfigRequest));
+ ::fidl::DecodedMessage<CheckConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::CheckConfig(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::CheckConfig Controller::SyncClient::CheckConfig(bool discard) {
+ return ResultOf::CheckConfig(::zx::unowned_channel(this->channel_), std::move(discard));
+}
+
+Controller::ResultOf::CheckConfig Controller::Call::CheckConfig(::zx::unowned_channel _client_end, bool discard) {
+ return ResultOf::CheckConfig(std::move(_client_end), std::move(discard));
+}
+
+template <>
+Controller::UnownedResultOf::CheckConfig_Impl<Controller::CheckConfigResponse>::CheckConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool discard, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CheckConfigRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CheckConfigResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CheckConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CheckConfigRequest*>(_request_buffer.data());
+ _request.discard = std::move(discard);
+ _request_buffer.set_actual(sizeof(CheckConfigRequest));
+ ::fidl::DecodedMessage<CheckConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::CheckConfig(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::CheckConfig Controller::SyncClient::CheckConfig(::fidl::BytePart _request_buffer, bool discard, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CheckConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(discard), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::CheckConfig Controller::Call::CheckConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool discard, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CheckConfig(std::move(_client_end), std::move(_request_buffer), std::move(discard), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::CheckConfigResponse> Controller::InPlace::CheckConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CheckConfigRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::CheckConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::CheckConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CheckConfigRequest, CheckConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::CheckConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Controller::ResultOf::ApplyConfig_Impl::ApplyConfig_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ApplyConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ApplyConfigRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ApplyConfigRequest));
+ ::fidl::DecodedMessage<ApplyConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::ApplyConfig(std::move(_client_end)));
+}
+
+Controller::ResultOf::ApplyConfig Controller::SyncClient::ApplyConfig() {
+ return ResultOf::ApplyConfig(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::ApplyConfig Controller::Call::ApplyConfig(::zx::unowned_channel _client_end) {
+ return ResultOf::ApplyConfig(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::ApplyConfig(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(ApplyConfigRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ApplyConfigRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::ApplyConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::EnableVsync_Impl::EnableVsync_Impl(::zx::unowned_channel _client_end, bool enable) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EnableVsyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, EnableVsyncRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<EnableVsyncRequest*>(_write_bytes);
+ _request.enable = std::move(enable);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(EnableVsyncRequest));
+ ::fidl::DecodedMessage<EnableVsyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::EnableVsync(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::EnableVsync Controller::SyncClient::EnableVsync(bool enable) {
+ return ResultOf::EnableVsync(::zx::unowned_channel(this->channel_), std::move(enable));
+}
+
+Controller::ResultOf::EnableVsync Controller::Call::EnableVsync(::zx::unowned_channel _client_end, bool enable) {
+ return ResultOf::EnableVsync(std::move(_client_end), std::move(enable));
+}
+
+
+Controller::UnownedResultOf::EnableVsync_Impl::EnableVsync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable) {
+ if (_request_buffer.capacity() < EnableVsyncRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, EnableVsyncRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<EnableVsyncRequest*>(_request_buffer.data());
+ _request.enable = std::move(enable);
+ _request_buffer.set_actual(sizeof(EnableVsyncRequest));
+ ::fidl::DecodedMessage<EnableVsyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::EnableVsync(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::EnableVsync Controller::SyncClient::EnableVsync(::fidl::BytePart _request_buffer, bool enable) {
+ return UnownedResultOf::EnableVsync(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(enable));
+}
+
+Controller::UnownedResultOf::EnableVsync Controller::Call::EnableVsync(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable) {
+ return UnownedResultOf::EnableVsync(std::move(_client_end), std::move(_request_buffer), std::move(enable));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::EnableVsync(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EnableVsyncRequest> params) {
+ Controller::SetTransactionHeaderFor::EnableVsyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Controller::ResultOf::SetVirtconMode_Impl::SetVirtconMode_Impl(::zx::unowned_channel _client_end, uint8_t mode) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetVirtconModeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetVirtconModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetVirtconModeRequest*>(_write_bytes);
+ _request.mode = std::move(mode);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetVirtconModeRequest));
+ ::fidl::DecodedMessage<SetVirtconModeRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::SetVirtconMode(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::SetVirtconMode Controller::SyncClient::SetVirtconMode(uint8_t mode) {
+ return ResultOf::SetVirtconMode(::zx::unowned_channel(this->channel_), std::move(mode));
+}
+
+Controller::ResultOf::SetVirtconMode Controller::Call::SetVirtconMode(::zx::unowned_channel _client_end, uint8_t mode) {
+ return ResultOf::SetVirtconMode(std::move(_client_end), std::move(mode));
+}
+
+
+Controller::UnownedResultOf::SetVirtconMode_Impl::SetVirtconMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t mode) {
+ if (_request_buffer.capacity() < SetVirtconModeRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetVirtconModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetVirtconModeRequest*>(_request_buffer.data());
+ _request.mode = std::move(mode);
+ _request_buffer.set_actual(sizeof(SetVirtconModeRequest));
+ ::fidl::DecodedMessage<SetVirtconModeRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::SetVirtconMode(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::SetVirtconMode Controller::SyncClient::SetVirtconMode(::fidl::BytePart _request_buffer, uint8_t mode) {
+ return UnownedResultOf::SetVirtconMode(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mode));
+}
+
+Controller::UnownedResultOf::SetVirtconMode Controller::Call::SetVirtconMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t mode) {
+ return UnownedResultOf::SetVirtconMode(std::move(_client_end), std::move(_request_buffer), std::move(mode));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::SetVirtconMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetVirtconModeRequest> params) {
+ Controller::SetTransactionHeaderFor::SetVirtconModeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Controller::ResultOf::ImportBufferCollection_Impl<Controller::ImportBufferCollectionResponse>::ImportBufferCollection_Impl(::zx::unowned_channel _client_end, uint64_t collection_id, ::zx::channel collection_token) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportBufferCollectionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ImportBufferCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportBufferCollectionRequest*>(_write_bytes);
+ _request.collection_id = std::move(collection_id);
+ _request.collection_token = std::move(collection_token);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ImportBufferCollectionRequest));
+ ::fidl::DecodedMessage<ImportBufferCollectionRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::ImportBufferCollection(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::ImportBufferCollection Controller::SyncClient::ImportBufferCollection(uint64_t collection_id, ::zx::channel collection_token) {
+ return ResultOf::ImportBufferCollection(::zx::unowned_channel(this->channel_), std::move(collection_id), std::move(collection_token));
+}
+
+Controller::ResultOf::ImportBufferCollection Controller::Call::ImportBufferCollection(::zx::unowned_channel _client_end, uint64_t collection_id, ::zx::channel collection_token) {
+ return ResultOf::ImportBufferCollection(std::move(_client_end), std::move(collection_id), std::move(collection_token));
+}
+
+template <>
+Controller::UnownedResultOf::ImportBufferCollection_Impl<Controller::ImportBufferCollectionResponse>::ImportBufferCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id, ::zx::channel collection_token, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ImportBufferCollectionRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ImportBufferCollectionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ImportBufferCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportBufferCollectionRequest*>(_request_buffer.data());
+ _request.collection_id = std::move(collection_id);
+ _request.collection_token = std::move(collection_token);
+ _request_buffer.set_actual(sizeof(ImportBufferCollectionRequest));
+ ::fidl::DecodedMessage<ImportBufferCollectionRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::ImportBufferCollection(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::ImportBufferCollection Controller::SyncClient::ImportBufferCollection(::fidl::BytePart _request_buffer, uint64_t collection_id, ::zx::channel collection_token, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ImportBufferCollection(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(collection_id), std::move(collection_token), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::ImportBufferCollection Controller::Call::ImportBufferCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id, ::zx::channel collection_token, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ImportBufferCollection(std::move(_client_end), std::move(_request_buffer), std::move(collection_id), std::move(collection_token), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ImportBufferCollectionResponse> Controller::InPlace::ImportBufferCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportBufferCollectionRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::ImportBufferCollectionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ImportBufferCollectionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ImportBufferCollectionRequest, ImportBufferCollectionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ImportBufferCollectionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Controller::ResultOf::ReleaseBufferCollection_Impl::ReleaseBufferCollection_Impl(::zx::unowned_channel _client_end, uint64_t collection_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseBufferCollectionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReleaseBufferCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseBufferCollectionRequest*>(_write_bytes);
+ _request.collection_id = std::move(collection_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReleaseBufferCollectionRequest));
+ ::fidl::DecodedMessage<ReleaseBufferCollectionRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Controller::InPlace::ReleaseBufferCollection(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::ResultOf::ReleaseBufferCollection Controller::SyncClient::ReleaseBufferCollection(uint64_t collection_id) {
+ return ResultOf::ReleaseBufferCollection(::zx::unowned_channel(this->channel_), std::move(collection_id));
+}
+
+Controller::ResultOf::ReleaseBufferCollection Controller::Call::ReleaseBufferCollection(::zx::unowned_channel _client_end, uint64_t collection_id) {
+ return ResultOf::ReleaseBufferCollection(std::move(_client_end), std::move(collection_id));
+}
+
+
+Controller::UnownedResultOf::ReleaseBufferCollection_Impl::ReleaseBufferCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id) {
+ if (_request_buffer.capacity() < ReleaseBufferCollectionRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReleaseBufferCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseBufferCollectionRequest*>(_request_buffer.data());
+ _request.collection_id = std::move(collection_id);
+ _request_buffer.set_actual(sizeof(ReleaseBufferCollectionRequest));
+ ::fidl::DecodedMessage<ReleaseBufferCollectionRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Controller::InPlace::ReleaseBufferCollection(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Controller::UnownedResultOf::ReleaseBufferCollection Controller::SyncClient::ReleaseBufferCollection(::fidl::BytePart _request_buffer, uint64_t collection_id) {
+ return UnownedResultOf::ReleaseBufferCollection(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(collection_id));
+}
+
+Controller::UnownedResultOf::ReleaseBufferCollection Controller::Call::ReleaseBufferCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id) {
+ return UnownedResultOf::ReleaseBufferCollection(std::move(_client_end), std::move(_request_buffer), std::move(collection_id));
+}
+
+::fidl::internal::StatusAndError Controller::InPlace::ReleaseBufferCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseBufferCollectionRequest> params) {
+ Controller::SetTransactionHeaderFor::ReleaseBufferCollectionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Controller::ResultOf::SetBufferCollectionConstraints_Impl<Controller::SetBufferCollectionConstraintsResponse>::SetBufferCollectionConstraints_Impl(::zx::unowned_channel _client_end, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetBufferCollectionConstraintsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetBufferCollectionConstraintsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetBufferCollectionConstraintsRequest*>(_write_bytes);
+ _request.collection_id = std::move(collection_id);
+ _request.config = std::move(config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetBufferCollectionConstraintsRequest));
+ ::fidl::DecodedMessage<SetBufferCollectionConstraintsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::SetBufferCollectionConstraints(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::SetBufferCollectionConstraints Controller::SyncClient::SetBufferCollectionConstraints(uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config) {
+ return ResultOf::SetBufferCollectionConstraints(::zx::unowned_channel(this->channel_), std::move(collection_id), std::move(config));
+}
+
+Controller::ResultOf::SetBufferCollectionConstraints Controller::Call::SetBufferCollectionConstraints(::zx::unowned_channel _client_end, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config) {
+ return ResultOf::SetBufferCollectionConstraints(std::move(_client_end), std::move(collection_id), std::move(config));
+}
+
+template <>
+Controller::UnownedResultOf::SetBufferCollectionConstraints_Impl<Controller::SetBufferCollectionConstraintsResponse>::SetBufferCollectionConstraints_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetBufferCollectionConstraintsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetBufferCollectionConstraintsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetBufferCollectionConstraintsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetBufferCollectionConstraintsRequest*>(_request_buffer.data());
+ _request.collection_id = std::move(collection_id);
+ _request.config = std::move(config);
+ _request_buffer.set_actual(sizeof(SetBufferCollectionConstraintsRequest));
+ ::fidl::DecodedMessage<SetBufferCollectionConstraintsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::SetBufferCollectionConstraints(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::SetBufferCollectionConstraints Controller::SyncClient::SetBufferCollectionConstraints(::fidl::BytePart _request_buffer, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetBufferCollectionConstraints(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(collection_id), std::move(config), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::SetBufferCollectionConstraints Controller::Call::SetBufferCollectionConstraints(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetBufferCollectionConstraints(std::move(_client_end), std::move(_request_buffer), std::move(collection_id), std::move(config), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::SetBufferCollectionConstraintsResponse> Controller::InPlace::SetBufferCollectionConstraints(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetBufferCollectionConstraintsRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::SetBufferCollectionConstraintsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::SetBufferCollectionConstraintsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetBufferCollectionConstraintsRequest, SetBufferCollectionConstraintsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::SetBufferCollectionConstraintsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetSingleBufferFramebuffer_Impl<Controller::GetSingleBufferFramebufferResponse>::GetSingleBufferFramebuffer_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSingleBufferFramebufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSingleBufferFramebufferRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSingleBufferFramebufferRequest));
+ ::fidl::DecodedMessage<GetSingleBufferFramebufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetSingleBufferFramebuffer(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetSingleBufferFramebuffer Controller::SyncClient::GetSingleBufferFramebuffer() {
+ return ResultOf::GetSingleBufferFramebuffer(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetSingleBufferFramebuffer Controller::Call::GetSingleBufferFramebuffer(::zx::unowned_channel _client_end) {
+ return ResultOf::GetSingleBufferFramebuffer(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetSingleBufferFramebuffer_Impl<Controller::GetSingleBufferFramebufferResponse>::GetSingleBufferFramebuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetSingleBufferFramebufferRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetSingleBufferFramebufferRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetSingleBufferFramebufferRequest));
+ ::fidl::DecodedMessage<GetSingleBufferFramebufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetSingleBufferFramebuffer(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetSingleBufferFramebuffer Controller::SyncClient::GetSingleBufferFramebuffer(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSingleBufferFramebuffer(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetSingleBufferFramebuffer Controller::Call::GetSingleBufferFramebuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSingleBufferFramebuffer(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetSingleBufferFramebufferResponse> Controller::InPlace::GetSingleBufferFramebuffer(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetSingleBufferFramebufferRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetSingleBufferFramebufferRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetSingleBufferFramebufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetSingleBufferFramebufferResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSingleBufferFramebufferRequest, GetSingleBufferFramebufferResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetSingleBufferFramebufferResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::IsCaptureSupported_Impl<Controller::IsCaptureSupportedResponse>::IsCaptureSupported_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<IsCaptureSupportedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, IsCaptureSupportedRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(IsCaptureSupportedRequest));
+ ::fidl::DecodedMessage<IsCaptureSupportedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::IsCaptureSupported(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::IsCaptureSupported Controller::SyncClient::IsCaptureSupported() {
+ return ResultOf::IsCaptureSupported(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::IsCaptureSupported Controller::Call::IsCaptureSupported(::zx::unowned_channel _client_end) {
+ return ResultOf::IsCaptureSupported(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::IsCaptureSupported_Impl<Controller::IsCaptureSupportedResponse>::IsCaptureSupported_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(IsCaptureSupportedRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, IsCaptureSupportedRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(IsCaptureSupportedRequest));
+ ::fidl::DecodedMessage<IsCaptureSupportedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::IsCaptureSupported(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::IsCaptureSupported Controller::SyncClient::IsCaptureSupported(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::IsCaptureSupported(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::IsCaptureSupported Controller::Call::IsCaptureSupported(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::IsCaptureSupported(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::IsCaptureSupportedResponse> Controller::InPlace::IsCaptureSupported(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(IsCaptureSupportedRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<IsCaptureSupportedRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::IsCaptureSupportedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::IsCaptureSupportedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<IsCaptureSupportedRequest, IsCaptureSupportedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::IsCaptureSupportedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::ImportImageForCapture_Impl<Controller::ImportImageForCaptureResponse>::ImportImageForCapture_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportImageForCaptureRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ImportImageForCaptureRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportImageForCaptureRequest*>(_write_bytes);
+ _request.image_config = std::move(image_config);
+ _request.collection_id = std::move(collection_id);
+ _request.index = std::move(index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ImportImageForCaptureRequest));
+ ::fidl::DecodedMessage<ImportImageForCaptureRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::ImportImageForCapture(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::ImportImageForCapture Controller::SyncClient::ImportImageForCapture(::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index) {
+ return ResultOf::ImportImageForCapture(::zx::unowned_channel(this->channel_), std::move(image_config), std::move(collection_id), std::move(index));
+}
+
+Controller::ResultOf::ImportImageForCapture Controller::Call::ImportImageForCapture(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index) {
+ return ResultOf::ImportImageForCapture(std::move(_client_end), std::move(image_config), std::move(collection_id), std::move(index));
+}
+
+template <>
+Controller::UnownedResultOf::ImportImageForCapture_Impl<Controller::ImportImageForCaptureResponse>::ImportImageForCapture_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ImportImageForCaptureRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ImportImageForCaptureResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ImportImageForCaptureRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ImportImageForCaptureRequest*>(_request_buffer.data());
+ _request.image_config = std::move(image_config);
+ _request.collection_id = std::move(collection_id);
+ _request.index = std::move(index);
+ _request_buffer.set_actual(sizeof(ImportImageForCaptureRequest));
+ ::fidl::DecodedMessage<ImportImageForCaptureRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::ImportImageForCapture(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::ImportImageForCapture Controller::SyncClient::ImportImageForCapture(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ImportImageForCapture(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(image_config), std::move(collection_id), std::move(index), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::ImportImageForCapture Controller::Call::ImportImageForCapture(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ImportImageForCapture(std::move(_client_end), std::move(_request_buffer), std::move(image_config), std::move(collection_id), std::move(index), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ImportImageForCaptureResponse> Controller::InPlace::ImportImageForCapture(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportImageForCaptureRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::ImportImageForCaptureRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ImportImageForCaptureResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ImportImageForCaptureRequest, ImportImageForCaptureResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ImportImageForCaptureResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::StartCapture_Impl<Controller::StartCaptureResponse>::StartCapture_Impl(::zx::unowned_channel _client_end, uint64_t signal_event_id, uint64_t image_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartCaptureRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StartCaptureRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<StartCaptureRequest*>(_write_bytes);
+ _request.signal_event_id = std::move(signal_event_id);
+ _request.image_id = std::move(image_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartCaptureRequest));
+ ::fidl::DecodedMessage<StartCaptureRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::StartCapture(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::StartCapture Controller::SyncClient::StartCapture(uint64_t signal_event_id, uint64_t image_id) {
+ return ResultOf::StartCapture(::zx::unowned_channel(this->channel_), std::move(signal_event_id), std::move(image_id));
+}
+
+Controller::ResultOf::StartCapture Controller::Call::StartCapture(::zx::unowned_channel _client_end, uint64_t signal_event_id, uint64_t image_id) {
+ return ResultOf::StartCapture(std::move(_client_end), std::move(signal_event_id), std::move(image_id));
+}
+
+template <>
+Controller::UnownedResultOf::StartCapture_Impl<Controller::StartCaptureResponse>::StartCapture_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t signal_event_id, uint64_t image_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < StartCaptureRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<StartCaptureResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, StartCaptureRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<StartCaptureRequest*>(_request_buffer.data());
+ _request.signal_event_id = std::move(signal_event_id);
+ _request.image_id = std::move(image_id);
+ _request_buffer.set_actual(sizeof(StartCaptureRequest));
+ ::fidl::DecodedMessage<StartCaptureRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::StartCapture(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::StartCapture Controller::SyncClient::StartCapture(::fidl::BytePart _request_buffer, uint64_t signal_event_id, uint64_t image_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StartCapture(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(signal_event_id), std::move(image_id), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::StartCapture Controller::Call::StartCapture(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t signal_event_id, uint64_t image_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StartCapture(std::move(_client_end), std::move(_request_buffer), std::move(signal_event_id), std::move(image_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::StartCaptureResponse> Controller::InPlace::StartCapture(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StartCaptureRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::StartCaptureRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StartCaptureResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StartCaptureRequest, StartCaptureResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StartCaptureResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::ReleaseCapture_Impl<Controller::ReleaseCaptureResponse>::ReleaseCapture_Impl(::zx::unowned_channel _client_end, uint64_t image_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseCaptureRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReleaseCaptureRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseCaptureRequest*>(_write_bytes);
+ _request.image_id = std::move(image_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReleaseCaptureRequest));
+ ::fidl::DecodedMessage<ReleaseCaptureRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::ReleaseCapture(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::ReleaseCapture Controller::SyncClient::ReleaseCapture(uint64_t image_id) {
+ return ResultOf::ReleaseCapture(::zx::unowned_channel(this->channel_), std::move(image_id));
+}
+
+Controller::ResultOf::ReleaseCapture Controller::Call::ReleaseCapture(::zx::unowned_channel _client_end, uint64_t image_id) {
+ return ResultOf::ReleaseCapture(std::move(_client_end), std::move(image_id));
+}
+
+template <>
+Controller::UnownedResultOf::ReleaseCapture_Impl<Controller::ReleaseCaptureResponse>::ReleaseCapture_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t image_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReleaseCaptureRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReleaseCaptureResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReleaseCaptureRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReleaseCaptureRequest*>(_request_buffer.data());
+ _request.image_id = std::move(image_id);
+ _request_buffer.set_actual(sizeof(ReleaseCaptureRequest));
+ ::fidl::DecodedMessage<ReleaseCaptureRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::ReleaseCapture(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::ReleaseCapture Controller::SyncClient::ReleaseCapture(::fidl::BytePart _request_buffer, uint64_t image_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReleaseCapture(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(image_id), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::ReleaseCapture Controller::Call::ReleaseCapture(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t image_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReleaseCapture(std::move(_client_end), std::move(_request_buffer), std::move(image_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::ReleaseCaptureResponse> Controller::InPlace::ReleaseCapture(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseCaptureRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::ReleaseCaptureRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ReleaseCaptureResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReleaseCaptureRequest, ReleaseCaptureResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::ReleaseCaptureResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Controller::SyncClient::HandleEvents(Controller::EventHandlers handlers) {
+ return Controller::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Controller::Call::HandleEvents(::zx::unowned_channel client_end, Controller::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<DisplaysChangedResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<DisplaysChangedResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ if (::fidl::internal::ClampedMessageSize<VsyncResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<VsyncResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ if (::fidl::internal::ClampedMessageSize<ClientOwnershipChangeResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<ClientOwnershipChangeResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (DisplaysChangedResponse::MaxNumHandles >= x) {
+ x = DisplaysChangedResponse::MaxNumHandles;
+ }
+ if (VsyncResponse::MaxNumHandles >= x) {
+ x = VsyncResponse::MaxNumHandles;
+ }
+ if (ClientOwnershipChangeResponse::MaxNumHandles >= x) {
+ x = ClientOwnershipChangeResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kController_DisplaysChanged_Ordinal:
+ case kController_DisplaysChanged_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DisplaysChangedResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.displays_changed(std::move(message->added), std::move(message->removed));
+ }
+ case kController_Vsync_Ordinal:
+ case kController_Vsync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<VsyncResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.vsync(std::move(message->display_id), std::move(message->timestamp), std::move(message->images));
+ }
+ case kController_ClientOwnershipChange_Ordinal:
+ case kController_ClientOwnershipChange_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ClientOwnershipChangeResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.client_ownership_change(std::move(message->has_ownership));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Controller::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kController_ImportVmoImage_Ordinal:
+ case kController_ImportVmoImage_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ImportVmoImageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ImportVmoImage(std::move(message->image_config), std::move(message->vmo), std::move(message->offset),
+ Interface::ImportVmoImageCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ImportImage_Ordinal:
+ case kController_ImportImage_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ImportImageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ImportImage(std::move(message->image_config), std::move(message->collection_id), std::move(message->index),
+ Interface::ImportImageCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ReleaseImage_Ordinal:
+ case kController_ReleaseImage_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReleaseImageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReleaseImage(std::move(message->image_id),
+ Interface::ReleaseImageCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ImportEvent_Ordinal:
+ case kController_ImportEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ImportEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ImportEvent(std::move(message->event), std::move(message->id),
+ Interface::ImportEventCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ReleaseEvent_Ordinal:
+ case kController_ReleaseEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReleaseEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReleaseEvent(std::move(message->id),
+ Interface::ReleaseEventCompleter::Sync(txn));
+ return true;
+ }
+ case kController_CreateLayer_Ordinal:
+ case kController_CreateLayer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateLayerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->CreateLayer(
+ Interface::CreateLayerCompleter::Sync(txn));
+ return true;
+ }
+ case kController_DestroyLayer_Ordinal:
+ case kController_DestroyLayer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DestroyLayerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->DestroyLayer(std::move(message->layer_id),
+ Interface::DestroyLayerCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetDisplayMode_Ordinal:
+ case kController_SetDisplayMode_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetDisplayModeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetDisplayMode(std::move(message->display_id), std::move(message->mode),
+ Interface::SetDisplayModeCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetDisplayColorConversion_Ordinal:
+ case kController_SetDisplayColorConversion_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetDisplayColorConversionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetDisplayColorConversion(std::move(message->display_id), std::move(message->preoffsets), std::move(message->coefficients), std::move(message->postoffsets),
+ Interface::SetDisplayColorConversionCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetDisplayLayers_Ordinal:
+ case kController_SetDisplayLayers_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetDisplayLayersRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetDisplayLayers(std::move(message->display_id), std::move(message->layer_ids),
+ Interface::SetDisplayLayersCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetLayerPrimaryConfig_Ordinal:
+ case kController_SetLayerPrimaryConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetLayerPrimaryConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetLayerPrimaryConfig(std::move(message->layer_id), std::move(message->image_config),
+ Interface::SetLayerPrimaryConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetLayerPrimaryPosition_Ordinal:
+ case kController_SetLayerPrimaryPosition_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetLayerPrimaryPositionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetLayerPrimaryPosition(std::move(message->layer_id), std::move(message->transform), std::move(message->src_frame), std::move(message->dest_frame),
+ Interface::SetLayerPrimaryPositionCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetLayerPrimaryAlpha_Ordinal:
+ case kController_SetLayerPrimaryAlpha_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetLayerPrimaryAlphaRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetLayerPrimaryAlpha(std::move(message->layer_id), std::move(message->mode), std::move(message->val),
+ Interface::SetLayerPrimaryAlphaCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetLayerCursorConfig_Ordinal:
+ case kController_SetLayerCursorConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetLayerCursorConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetLayerCursorConfig(std::move(message->layer_id), std::move(message->image_config),
+ Interface::SetLayerCursorConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetLayerCursorPosition_Ordinal:
+ case kController_SetLayerCursorPosition_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetLayerCursorPositionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetLayerCursorPosition(std::move(message->layer_id), std::move(message->x), std::move(message->y),
+ Interface::SetLayerCursorPositionCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetLayerColorConfig_Ordinal:
+ case kController_SetLayerColorConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetLayerColorConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetLayerColorConfig(std::move(message->layer_id), std::move(message->pixel_format), std::move(message->color_bytes),
+ Interface::SetLayerColorConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetLayerImage_Ordinal:
+ case kController_SetLayerImage_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetLayerImageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetLayerImage(std::move(message->layer_id), std::move(message->image_id), std::move(message->wait_event_id), std::move(message->signal_event_id),
+ Interface::SetLayerImageCompleter::Sync(txn));
+ return true;
+ }
+ case kController_CheckConfig_Ordinal:
+ case kController_CheckConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CheckConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CheckConfig(std::move(message->discard),
+ Interface::CheckConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ApplyConfig_Ordinal:
+ case kController_ApplyConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ApplyConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ApplyConfig(
+ Interface::ApplyConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kController_EnableVsync_Ordinal:
+ case kController_EnableVsync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EnableVsyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->EnableVsync(std::move(message->enable),
+ Interface::EnableVsyncCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetVirtconMode_Ordinal:
+ case kController_SetVirtconMode_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetVirtconModeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetVirtconMode(std::move(message->mode),
+ Interface::SetVirtconModeCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ImportBufferCollection_Ordinal:
+ case kController_ImportBufferCollection_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ImportBufferCollectionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ImportBufferCollection(std::move(message->collection_id), std::move(message->collection_token),
+ Interface::ImportBufferCollectionCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ReleaseBufferCollection_Ordinal:
+ case kController_ReleaseBufferCollection_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReleaseBufferCollectionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReleaseBufferCollection(std::move(message->collection_id),
+ Interface::ReleaseBufferCollectionCompleter::Sync(txn));
+ return true;
+ }
+ case kController_SetBufferCollectionConstraints_Ordinal:
+ case kController_SetBufferCollectionConstraints_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetBufferCollectionConstraintsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetBufferCollectionConstraints(std::move(message->collection_id), std::move(message->config),
+ Interface::SetBufferCollectionConstraintsCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetSingleBufferFramebuffer_Ordinal:
+ case kController_GetSingleBufferFramebuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSingleBufferFramebufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetSingleBufferFramebuffer(
+ Interface::GetSingleBufferFramebufferCompleter::Sync(txn));
+ return true;
+ }
+ case kController_IsCaptureSupported_Ordinal:
+ case kController_IsCaptureSupported_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<IsCaptureSupportedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->IsCaptureSupported(
+ Interface::IsCaptureSupportedCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ImportImageForCapture_Ordinal:
+ case kController_ImportImageForCapture_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ImportImageForCaptureRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ImportImageForCapture(std::move(message->image_config), std::move(message->collection_id), std::move(message->index),
+ Interface::ImportImageForCaptureCompleter::Sync(txn));
+ return true;
+ }
+ case kController_StartCapture_Ordinal:
+ case kController_StartCapture_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StartCaptureRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->StartCapture(std::move(message->signal_event_id), std::move(message->image_id),
+ Interface::StartCaptureCompleter::Sync(txn));
+ return true;
+ }
+ case kController_ReleaseCapture_Ordinal:
+ case kController_ReleaseCapture_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReleaseCaptureRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReleaseCapture(std::move(message->image_id),
+ Interface::ReleaseCaptureCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Controller::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+zx_status_t Controller::SendDisplaysChangedEvent(::zx::unowned_channel _chan, ::fidl::VectorView<::llcpp::fuchsia::hardware::display::Info> added, ::fidl::VectorView<uint64_t> removed) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DisplaysChangedResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ DisplaysChangedResponse _response = {};
+ Controller::SetTransactionHeaderFor::DisplaysChangedResponse(
+ ::fidl::DecodedMessage<DisplaysChangedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DisplaysChangedResponse::PrimarySize,
+ DisplaysChangedResponse::PrimarySize)));
+ _response.added = std::move(added);
+ _response.removed = std::move(removed);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Controller::SendDisplaysChangedEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::hardware::display::Info> added, ::fidl::VectorView<uint64_t> removed) {
+ if (_buffer.capacity() < DisplaysChangedResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ DisplaysChangedResponse _response = {};
+ Controller::SetTransactionHeaderFor::DisplaysChangedResponse(
+ ::fidl::DecodedMessage<DisplaysChangedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DisplaysChangedResponse::PrimarySize,
+ DisplaysChangedResponse::PrimarySize)));
+ _response.added = std::move(added);
+ _response.removed = std::move(removed);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Controller::SendDisplaysChangedEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<DisplaysChangedResponse> params) {
+ Controller::SetTransactionHeaderFor::DisplaysChangedResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Controller::Interface::ImportVmoImageCompleterBase::Reply(int32_t res, uint64_t image_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportVmoImageResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ImportVmoImageResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::ImportVmoImageResponse(
+ ::fidl::DecodedMessage<ImportVmoImageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ImportVmoImageResponse::PrimarySize,
+ ImportVmoImageResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.image_id = std::move(image_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ImportVmoImageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ImportVmoImageResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::ImportVmoImageCompleterBase::Reply(::fidl::BytePart _buffer, int32_t res, uint64_t image_id) {
+ if (_buffer.capacity() < ImportVmoImageResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ImportVmoImageResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::ImportVmoImageResponse(
+ ::fidl::DecodedMessage<ImportVmoImageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ImportVmoImageResponse::PrimarySize,
+ ImportVmoImageResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.image_id = std::move(image_id);
+ _buffer.set_actual(sizeof(ImportVmoImageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ImportVmoImageResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::ImportVmoImageCompleterBase::Reply(::fidl::DecodedMessage<ImportVmoImageResponse> params) {
+ Controller::SetTransactionHeaderFor::ImportVmoImageResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::ImportImageCompleterBase::Reply(int32_t res, uint64_t image_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportImageResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ImportImageResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::ImportImageResponse(
+ ::fidl::DecodedMessage<ImportImageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ImportImageResponse::PrimarySize,
+ ImportImageResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.image_id = std::move(image_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ImportImageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ImportImageResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::ImportImageCompleterBase::Reply(::fidl::BytePart _buffer, int32_t res, uint64_t image_id) {
+ if (_buffer.capacity() < ImportImageResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ImportImageResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::ImportImageResponse(
+ ::fidl::DecodedMessage<ImportImageResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ImportImageResponse::PrimarySize,
+ ImportImageResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.image_id = std::move(image_id);
+ _buffer.set_actual(sizeof(ImportImageResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ImportImageResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::ImportImageCompleterBase::Reply(::fidl::DecodedMessage<ImportImageResponse> params) {
+ Controller::SetTransactionHeaderFor::ImportImageResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::CreateLayerCompleterBase::Reply(int32_t res, uint64_t layer_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateLayerResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CreateLayerResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::CreateLayerResponse(
+ ::fidl::DecodedMessage<CreateLayerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLayerResponse::PrimarySize,
+ CreateLayerResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.layer_id = std::move(layer_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateLayerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLayerResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::CreateLayerCompleterBase::Reply(::fidl::BytePart _buffer, int32_t res, uint64_t layer_id) {
+ if (_buffer.capacity() < CreateLayerResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CreateLayerResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::CreateLayerResponse(
+ ::fidl::DecodedMessage<CreateLayerResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateLayerResponse::PrimarySize,
+ CreateLayerResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.layer_id = std::move(layer_id);
+ _buffer.set_actual(sizeof(CreateLayerResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateLayerResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::CreateLayerCompleterBase::Reply(::fidl::DecodedMessage<CreateLayerResponse> params) {
+ Controller::SetTransactionHeaderFor::CreateLayerResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::CheckConfigCompleterBase::Reply(::llcpp::fuchsia::hardware::display::ConfigResult res, ::fidl::VectorView<::llcpp::fuchsia::hardware::display::ClientCompositionOp> ops) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CheckConfigResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ CheckConfigResponse _response = {};
+ Controller::SetTransactionHeaderFor::CheckConfigResponse(
+ ::fidl::DecodedMessage<CheckConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CheckConfigResponse::PrimarySize,
+ CheckConfigResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.ops = std::move(ops);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::CheckConfigCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::ConfigResult res, ::fidl::VectorView<::llcpp::fuchsia::hardware::display::ClientCompositionOp> ops) {
+ if (_buffer.capacity() < CheckConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CheckConfigResponse _response = {};
+ Controller::SetTransactionHeaderFor::CheckConfigResponse(
+ ::fidl::DecodedMessage<CheckConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CheckConfigResponse::PrimarySize,
+ CheckConfigResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.ops = std::move(ops);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::CheckConfigCompleterBase::Reply(::fidl::DecodedMessage<CheckConfigResponse> params) {
+ Controller::SetTransactionHeaderFor::CheckConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Controller::SendVsyncEvent(::zx::unowned_channel _chan, uint64_t display_id, uint64_t timestamp, ::fidl::VectorView<uint64_t> images) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<VsyncResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ VsyncResponse _response = {};
+ Controller::SetTransactionHeaderFor::VsyncResponse(
+ ::fidl::DecodedMessage<VsyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ VsyncResponse::PrimarySize,
+ VsyncResponse::PrimarySize)));
+ _response.display_id = std::move(display_id);
+ _response.timestamp = std::move(timestamp);
+ _response.images = std::move(images);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Controller::SendVsyncEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t display_id, uint64_t timestamp, ::fidl::VectorView<uint64_t> images) {
+ if (_buffer.capacity() < VsyncResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ VsyncResponse _response = {};
+ Controller::SetTransactionHeaderFor::VsyncResponse(
+ ::fidl::DecodedMessage<VsyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ VsyncResponse::PrimarySize,
+ VsyncResponse::PrimarySize)));
+ _response.display_id = std::move(display_id);
+ _response.timestamp = std::move(timestamp);
+ _response.images = std::move(images);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Controller::SendVsyncEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<VsyncResponse> params) {
+ Controller::SetTransactionHeaderFor::VsyncResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+zx_status_t Controller::SendClientOwnershipChangeEvent(::zx::unowned_channel _chan, bool has_ownership) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ClientOwnershipChangeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ClientOwnershipChangeResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::ClientOwnershipChangeResponse(
+ ::fidl::DecodedMessage<ClientOwnershipChangeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ClientOwnershipChangeResponse::PrimarySize,
+ ClientOwnershipChangeResponse::PrimarySize)));
+ _response.has_ownership = std::move(has_ownership);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ClientOwnershipChangeResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<ClientOwnershipChangeResponse>(std::move(_response_bytes)));
+}
+
+zx_status_t Controller::SendClientOwnershipChangeEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, bool has_ownership) {
+ if (_buffer.capacity() < ClientOwnershipChangeResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ auto& _response = *reinterpret_cast<ClientOwnershipChangeResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::ClientOwnershipChangeResponse(
+ ::fidl::DecodedMessage<ClientOwnershipChangeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ClientOwnershipChangeResponse::PrimarySize,
+ ClientOwnershipChangeResponse::PrimarySize)));
+ _response.has_ownership = std::move(has_ownership);
+ _buffer.set_actual(sizeof(ClientOwnershipChangeResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<ClientOwnershipChangeResponse>(std::move(_buffer)));
+}
+
+zx_status_t Controller::SendClientOwnershipChangeEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<ClientOwnershipChangeResponse> params) {
+ Controller::SetTransactionHeaderFor::ClientOwnershipChangeResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Controller::Interface::ImportBufferCollectionCompleterBase::Reply(int32_t res) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportBufferCollectionResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ImportBufferCollectionResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::ImportBufferCollectionResponse(
+ ::fidl::DecodedMessage<ImportBufferCollectionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ImportBufferCollectionResponse::PrimarySize,
+ ImportBufferCollectionResponse::PrimarySize)));
+ _response.res = std::move(res);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ImportBufferCollectionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ImportBufferCollectionResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::ImportBufferCollectionCompleterBase::Reply(::fidl::BytePart _buffer, int32_t res) {
+ if (_buffer.capacity() < ImportBufferCollectionResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ImportBufferCollectionResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::ImportBufferCollectionResponse(
+ ::fidl::DecodedMessage<ImportBufferCollectionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ImportBufferCollectionResponse::PrimarySize,
+ ImportBufferCollectionResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _buffer.set_actual(sizeof(ImportBufferCollectionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ImportBufferCollectionResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::ImportBufferCollectionCompleterBase::Reply(::fidl::DecodedMessage<ImportBufferCollectionResponse> params) {
+ Controller::SetTransactionHeaderFor::ImportBufferCollectionResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::SetBufferCollectionConstraintsCompleterBase::Reply(int32_t res) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetBufferCollectionConstraintsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetBufferCollectionConstraintsResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::SetBufferCollectionConstraintsResponse(
+ ::fidl::DecodedMessage<SetBufferCollectionConstraintsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetBufferCollectionConstraintsResponse::PrimarySize,
+ SetBufferCollectionConstraintsResponse::PrimarySize)));
+ _response.res = std::move(res);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetBufferCollectionConstraintsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetBufferCollectionConstraintsResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::SetBufferCollectionConstraintsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t res) {
+ if (_buffer.capacity() < SetBufferCollectionConstraintsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetBufferCollectionConstraintsResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::SetBufferCollectionConstraintsResponse(
+ ::fidl::DecodedMessage<SetBufferCollectionConstraintsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetBufferCollectionConstraintsResponse::PrimarySize,
+ SetBufferCollectionConstraintsResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _buffer.set_actual(sizeof(SetBufferCollectionConstraintsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetBufferCollectionConstraintsResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::SetBufferCollectionConstraintsCompleterBase::Reply(::fidl::DecodedMessage<SetBufferCollectionConstraintsResponse> params) {
+ Controller::SetTransactionHeaderFor::SetBufferCollectionConstraintsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetSingleBufferFramebufferCompleterBase::Reply(int32_t res, ::zx::vmo vmo, uint32_t stride) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSingleBufferFramebufferResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetSingleBufferFramebufferResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetSingleBufferFramebufferResponse(
+ ::fidl::DecodedMessage<GetSingleBufferFramebufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSingleBufferFramebufferResponse::PrimarySize,
+ GetSingleBufferFramebufferResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.vmo = std::move(vmo);
+ _response.stride = std::move(stride);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSingleBufferFramebufferResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetSingleBufferFramebufferResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetSingleBufferFramebufferCompleterBase::Reply(::fidl::BytePart _buffer, int32_t res, ::zx::vmo vmo, uint32_t stride) {
+ if (_buffer.capacity() < GetSingleBufferFramebufferResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetSingleBufferFramebufferResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetSingleBufferFramebufferResponse(
+ ::fidl::DecodedMessage<GetSingleBufferFramebufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSingleBufferFramebufferResponse::PrimarySize,
+ GetSingleBufferFramebufferResponse::PrimarySize)));
+ _response.res = std::move(res);
+ _response.vmo = std::move(vmo);
+ _response.stride = std::move(stride);
+ _buffer.set_actual(sizeof(GetSingleBufferFramebufferResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetSingleBufferFramebufferResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetSingleBufferFramebufferCompleterBase::Reply(::fidl::DecodedMessage<GetSingleBufferFramebufferResponse> params) {
+ Controller::SetTransactionHeaderFor::GetSingleBufferFramebufferResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::IsCaptureSupportedCompleterBase::Reply(::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<IsCaptureSupportedResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ IsCaptureSupportedResponse _response = {};
+ Controller::SetTransactionHeaderFor::IsCaptureSupportedResponse(
+ ::fidl::DecodedMessage<IsCaptureSupportedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ IsCaptureSupportedResponse::PrimarySize,
+ IsCaptureSupportedResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::IsCaptureSupportedCompleterBase::ReplySuccess(bool supported) {
+ Controller_IsCaptureSupported_Response response;
+ response.supported = std::move(supported);
+
+ Reply(Controller_IsCaptureSupported_Result::WithResponse(&response));
+}
+void Controller::Interface::IsCaptureSupportedCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_IsCaptureSupported_Result::WithErr(&error));
+}
+
+void Controller::Interface::IsCaptureSupportedCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Result result) {
+ if (_buffer.capacity() < IsCaptureSupportedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ IsCaptureSupportedResponse _response = {};
+ Controller::SetTransactionHeaderFor::IsCaptureSupportedResponse(
+ ::fidl::DecodedMessage<IsCaptureSupportedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ IsCaptureSupportedResponse::PrimarySize,
+ IsCaptureSupportedResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::IsCaptureSupportedCompleterBase::ReplySuccess(::fidl::BytePart _buffer, bool supported) {
+ Controller_IsCaptureSupported_Response response;
+ response.supported = std::move(supported);
+
+ Reply(std::move(_buffer), Controller_IsCaptureSupported_Result::WithResponse(&response));
+}
+
+void Controller::Interface::IsCaptureSupportedCompleterBase::Reply(::fidl::DecodedMessage<IsCaptureSupportedResponse> params) {
+ Controller::SetTransactionHeaderFor::IsCaptureSupportedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::ImportImageForCaptureCompleterBase::Reply(::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ImportImageForCaptureResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ImportImageForCaptureResponse _response = {};
+ Controller::SetTransactionHeaderFor::ImportImageForCaptureResponse(
+ ::fidl::DecodedMessage<ImportImageForCaptureResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ImportImageForCaptureResponse::PrimarySize,
+ ImportImageForCaptureResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ImportImageForCaptureCompleterBase::ReplySuccess(uint64_t image_id) {
+ Controller_ImportImageForCapture_Response response;
+ response.image_id = std::move(image_id);
+
+ Reply(Controller_ImportImageForCapture_Result::WithResponse(&response));
+}
+void Controller::Interface::ImportImageForCaptureCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_ImportImageForCapture_Result::WithErr(&error));
+}
+
+void Controller::Interface::ImportImageForCaptureCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Result result) {
+ if (_buffer.capacity() < ImportImageForCaptureResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ImportImageForCaptureResponse _response = {};
+ Controller::SetTransactionHeaderFor::ImportImageForCaptureResponse(
+ ::fidl::DecodedMessage<ImportImageForCaptureResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ImportImageForCaptureResponse::PrimarySize,
+ ImportImageForCaptureResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ImportImageForCaptureCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t image_id) {
+ Controller_ImportImageForCapture_Response response;
+ response.image_id = std::move(image_id);
+
+ Reply(std::move(_buffer), Controller_ImportImageForCapture_Result::WithResponse(&response));
+}
+
+void Controller::Interface::ImportImageForCaptureCompleterBase::Reply(::fidl::DecodedMessage<ImportImageForCaptureResponse> params) {
+ Controller::SetTransactionHeaderFor::ImportImageForCaptureResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::StartCaptureCompleterBase::Reply(::llcpp::fuchsia::hardware::display::Controller_StartCapture_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartCaptureResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ StartCaptureResponse _response = {};
+ Controller::SetTransactionHeaderFor::StartCaptureResponse(
+ ::fidl::DecodedMessage<StartCaptureResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartCaptureResponse::PrimarySize,
+ StartCaptureResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::StartCaptureCompleterBase::ReplySuccess() {
+ Controller_StartCapture_Response response;
+
+ Reply(Controller_StartCapture_Result::WithResponse(&response));
+}
+void Controller::Interface::StartCaptureCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_StartCapture_Result::WithErr(&error));
+}
+
+void Controller::Interface::StartCaptureCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::Controller_StartCapture_Result result) {
+ if (_buffer.capacity() < StartCaptureResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ StartCaptureResponse _response = {};
+ Controller::SetTransactionHeaderFor::StartCaptureResponse(
+ ::fidl::DecodedMessage<StartCaptureResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartCaptureResponse::PrimarySize,
+ StartCaptureResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::StartCaptureCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_StartCapture_Response response;
+
+ Reply(std::move(_buffer), Controller_StartCapture_Result::WithResponse(&response));
+}
+
+void Controller::Interface::StartCaptureCompleterBase::Reply(::fidl::DecodedMessage<StartCaptureResponse> params) {
+ Controller::SetTransactionHeaderFor::StartCaptureResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::ReleaseCaptureCompleterBase::Reply(::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReleaseCaptureResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ReleaseCaptureResponse _response = {};
+ Controller::SetTransactionHeaderFor::ReleaseCaptureResponse(
+ ::fidl::DecodedMessage<ReleaseCaptureResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReleaseCaptureResponse::PrimarySize,
+ ReleaseCaptureResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ReleaseCaptureCompleterBase::ReplySuccess() {
+ Controller_ReleaseCapture_Response response;
+
+ Reply(Controller_ReleaseCapture_Result::WithResponse(&response));
+}
+void Controller::Interface::ReleaseCaptureCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_ReleaseCapture_Result::WithErr(&error));
+}
+
+void Controller::Interface::ReleaseCaptureCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Result result) {
+ if (_buffer.capacity() < ReleaseCaptureResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReleaseCaptureResponse _response = {};
+ Controller::SetTransactionHeaderFor::ReleaseCaptureResponse(
+ ::fidl::DecodedMessage<ReleaseCaptureResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReleaseCaptureResponse::PrimarySize,
+ ReleaseCaptureResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::ReleaseCaptureCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_ReleaseCapture_Response response;
+
+ Reply(std::move(_buffer), Controller_ReleaseCapture_Result::WithResponse(&response));
+}
+
+void Controller::Interface::ReleaseCaptureCompleterBase::Reply(::fidl::DecodedMessage<ReleaseCaptureResponse> params) {
+ Controller::SetTransactionHeaderFor::ReleaseCaptureResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Controller::SetTransactionHeaderFor::DisplaysChangedResponse(const ::fidl::DecodedMessage<Controller::DisplaysChangedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_DisplaysChanged_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ImportVmoImageRequest(const ::fidl::DecodedMessage<Controller::ImportVmoImageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportVmoImage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ImportVmoImageResponse(const ::fidl::DecodedMessage<Controller::ImportVmoImageResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportVmoImage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ImportImageRequest(const ::fidl::DecodedMessage<Controller::ImportImageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportImage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ImportImageResponse(const ::fidl::DecodedMessage<Controller::ImportImageResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportImage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ReleaseImageRequest(const ::fidl::DecodedMessage<Controller::ReleaseImageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ReleaseImage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ImportEventRequest(const ::fidl::DecodedMessage<Controller::ImportEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ReleaseEventRequest(const ::fidl::DecodedMessage<Controller::ReleaseEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ReleaseEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::CreateLayerRequest(const ::fidl::DecodedMessage<Controller::CreateLayerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_CreateLayer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::CreateLayerResponse(const ::fidl::DecodedMessage<Controller::CreateLayerResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_CreateLayer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::DestroyLayerRequest(const ::fidl::DecodedMessage<Controller::DestroyLayerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_DestroyLayer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetDisplayModeRequest(const ::fidl::DecodedMessage<Controller::SetDisplayModeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetDisplayMode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetDisplayColorConversionRequest(const ::fidl::DecodedMessage<Controller::SetDisplayColorConversionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetDisplayColorConversion_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetDisplayLayersRequest(const ::fidl::DecodedMessage<Controller::SetDisplayLayersRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetDisplayLayers_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetLayerPrimaryConfigRequest(const ::fidl::DecodedMessage<Controller::SetLayerPrimaryConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetLayerPrimaryConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetLayerPrimaryPositionRequest(const ::fidl::DecodedMessage<Controller::SetLayerPrimaryPositionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetLayerPrimaryPosition_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetLayerPrimaryAlphaRequest(const ::fidl::DecodedMessage<Controller::SetLayerPrimaryAlphaRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetLayerPrimaryAlpha_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetLayerCursorConfigRequest(const ::fidl::DecodedMessage<Controller::SetLayerCursorConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetLayerCursorConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetLayerCursorPositionRequest(const ::fidl::DecodedMessage<Controller::SetLayerCursorPositionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetLayerCursorPosition_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetLayerColorConfigRequest(const ::fidl::DecodedMessage<Controller::SetLayerColorConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetLayerColorConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetLayerImageRequest(const ::fidl::DecodedMessage<Controller::SetLayerImageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetLayerImage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::CheckConfigRequest(const ::fidl::DecodedMessage<Controller::CheckConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_CheckConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::CheckConfigResponse(const ::fidl::DecodedMessage<Controller::CheckConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_CheckConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ApplyConfigRequest(const ::fidl::DecodedMessage<Controller::ApplyConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ApplyConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::EnableVsyncRequest(const ::fidl::DecodedMessage<Controller::EnableVsyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_EnableVsync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::VsyncResponse(const ::fidl::DecodedMessage<Controller::VsyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Vsync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetVirtconModeRequest(const ::fidl::DecodedMessage<Controller::SetVirtconModeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetVirtconMode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ClientOwnershipChangeResponse(const ::fidl::DecodedMessage<Controller::ClientOwnershipChangeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ClientOwnershipChange_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ImportBufferCollectionRequest(const ::fidl::DecodedMessage<Controller::ImportBufferCollectionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportBufferCollection_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ImportBufferCollectionResponse(const ::fidl::DecodedMessage<Controller::ImportBufferCollectionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportBufferCollection_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ReleaseBufferCollectionRequest(const ::fidl::DecodedMessage<Controller::ReleaseBufferCollectionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ReleaseBufferCollection_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::SetBufferCollectionConstraintsRequest(const ::fidl::DecodedMessage<Controller::SetBufferCollectionConstraintsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetBufferCollectionConstraints_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::SetBufferCollectionConstraintsResponse(const ::fidl::DecodedMessage<Controller::SetBufferCollectionConstraintsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_SetBufferCollectionConstraints_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetSingleBufferFramebufferRequest(const ::fidl::DecodedMessage<Controller::GetSingleBufferFramebufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetSingleBufferFramebuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetSingleBufferFramebufferResponse(const ::fidl::DecodedMessage<Controller::GetSingleBufferFramebufferResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetSingleBufferFramebuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::IsCaptureSupportedRequest(const ::fidl::DecodedMessage<Controller::IsCaptureSupportedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_IsCaptureSupported_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::IsCaptureSupportedResponse(const ::fidl::DecodedMessage<Controller::IsCaptureSupportedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_IsCaptureSupported_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ImportImageForCaptureRequest(const ::fidl::DecodedMessage<Controller::ImportImageForCaptureRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportImageForCapture_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ImportImageForCaptureResponse(const ::fidl::DecodedMessage<Controller::ImportImageForCaptureResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ImportImageForCapture_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::StartCaptureRequest(const ::fidl::DecodedMessage<Controller::StartCaptureRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_StartCapture_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::StartCaptureResponse(const ::fidl::DecodedMessage<Controller::StartCaptureResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_StartCapture_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::ReleaseCaptureRequest(const ::fidl::DecodedMessage<Controller::ReleaseCaptureRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ReleaseCapture_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::ReleaseCaptureResponse(const ::fidl::DecodedMessage<Controller::ReleaseCaptureResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_ReleaseCapture_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace display
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-display/gen/llcpp/include/fuchsia/hardware/display/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-display/gen/llcpp/include/fuchsia/hardware/display/llcpp/fidl.h
new file mode 100644
index 0000000..7039c5f
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-display/gen/llcpp/include/fuchsia/hardware/display/llcpp/fidl.h
@@ -0,0 +1,4015 @@
+// 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/event.h>
+#include <lib/zx/vmo.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/sysmem/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace display {
+
+struct ImageConfig;
+enum class VirtconMode : uint8_t {
+ INACTIVE = 0u,
+ FALLBACK = 1u,
+ FORCED = 2u,
+};
+
+
+enum class Transform : uint8_t {
+ IDENTITY = 0u,
+ REFLECT_X = 1u,
+ REFLECT_Y = 2u,
+ ROT_90 = 3u,
+ ROT_180 = 4u,
+ ROT_270 = 5u,
+ ROT_90_REFLECT_X = 6u,
+ ROT_90_REFLECT_Y = 7u,
+};
+
+
+class Provider;
+struct Mode;
+struct Frame;
+struct CursorInfo;
+struct Info;
+struct Controller_StartCapture_Response;
+struct Controller_StartCapture_Result;
+struct Controller_ReleaseCapture_Response;
+struct Controller_ReleaseCapture_Result;
+struct Controller_IsCaptureSupported_Response;
+struct Controller_IsCaptureSupported_Result;
+struct Controller_ImportImageForCapture_Response;
+struct Controller_ImportImageForCapture_Result;
+enum class ConfigResult : uint32_t {
+ OK = 0u,
+ INVALID_CONFIG = 1u,
+ UNSUPPORTED_CONFIG = 2u,
+ TOO_MANY_DISPLAYS = 3u,
+ UNSUPPORTED_DISPLAY_MODES = 4u,
+};
+
+
+enum class ClientCompositionOpcode : uint8_t {
+ CLIENT_USE_PRIMARY = 0u,
+ CLIENT_MERGE_BASE = 1u,
+ CLIENT_MERGE_SRC = 2u,
+ CLIENT_FRAME_SCALE = 3u,
+ CLIENT_SRC_FRAME = 4u,
+ CLIENT_TRANSFORM = 5u,
+ CLIENT_COLOR_CONVERSION = 6u,
+ CLIENT_ALPHA = 7u,
+};
+
+
+struct ClientCompositionOp;
+enum class AlphaMode : uint8_t {
+ DISABLE = 0u,
+ PREMULTIPLIED = 1u,
+ HW_MULTIPLY = 2u,
+};
+
+
+class Controller;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_Controller_StartCapture_ResultTable;
+
+struct Controller_StartCapture_Result {
+ Controller_StartCapture_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_StartCapture_Result WithResponse(::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response* val) {
+ Controller_StartCapture_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_StartCapture_Result WithErr(int32_t* val) {
+ Controller_StartCapture_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_Controller_StartCapture_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_Controller_ReleaseCapture_ResultTable;
+
+struct Controller_ReleaseCapture_Result {
+ Controller_ReleaseCapture_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_ReleaseCapture_Result WithResponse(::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response* val) {
+ Controller_ReleaseCapture_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_ReleaseCapture_Result WithErr(int32_t* val) {
+ Controller_ReleaseCapture_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_Controller_ReleaseCapture_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_Controller_IsCaptureSupported_ResultTable;
+
+struct Controller_IsCaptureSupported_Result {
+ Controller_IsCaptureSupported_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_IsCaptureSupported_Result WithResponse(::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response* val) {
+ Controller_IsCaptureSupported_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_IsCaptureSupported_Result WithErr(int32_t* val) {
+ Controller_IsCaptureSupported_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_Controller_IsCaptureSupported_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_Controller_ImportImageForCapture_ResultTable;
+
+struct Controller_ImportImageForCapture_Result {
+ Controller_ImportImageForCapture_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_ImportImageForCapture_Result WithResponse(::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response* val) {
+ Controller_ImportImageForCapture_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_ImportImageForCapture_Result WithErr(int32_t* val) {
+ Controller_ImportImageForCapture_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_Controller_ImportImageForCapture_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+constexpr uint32_t typeSimple = 0u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ImageConfigTable;
+
+struct ImageConfig {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ImageConfigTable;
+ 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;
+
+ uint32_t width = {};
+
+ uint32_t height = {};
+
+ uint32_t pixel_format = {};
+
+ uint32_t type = {};
+};
+
+constexpr uint32_t typeCapture = 10u;
+
+constexpr int32_t modeInterlaced = 1u;
+
+constexpr uint64_t invalidId = 0u;
+
+constexpr uint32_t identifierMaxLen = 128u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ProviderOpenVirtconControllerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ProviderOpenVirtconControllerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ProviderOpenControllerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ProviderOpenControllerResponseTable;
+
+// Provider for display controllers.
+//
+// The driver supports two simultaneous clients - a primary client and a virtcon
+// client.
+class Provider final {
+ Provider() = delete;
+ public:
+
+ struct OpenVirtconControllerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ProviderOpenVirtconControllerResponseTable;
+ 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 OpenVirtconControllerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel device;
+ ::zx::channel controller;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ProviderOpenVirtconControllerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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 = OpenVirtconControllerResponse;
+ };
+
+ struct OpenControllerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ProviderOpenControllerResponseTable;
+ 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 OpenControllerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel device;
+ ::zx::channel controller;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ProviderOpenControllerRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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 = OpenControllerResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class OpenVirtconController_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ OpenVirtconController_Impl(::zx::unowned_channel _client_end, ::zx::channel device, ::zx::channel controller);
+ ~OpenVirtconController_Impl() = default;
+ OpenVirtconController_Impl(OpenVirtconController_Impl&& other) = default;
+ OpenVirtconController_Impl& operator=(OpenVirtconController_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 OpenController_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ OpenController_Impl(::zx::unowned_channel _client_end, ::zx::channel device, ::zx::channel controller);
+ ~OpenController_Impl() = default;
+ OpenController_Impl(OpenController_Impl&& other) = default;
+ OpenController_Impl& operator=(OpenController_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 OpenVirtconController = OpenVirtconController_Impl<OpenVirtconControllerResponse>;
+ using OpenController = OpenController_Impl<OpenControllerResponse>;
+ };
+
+ // 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 OpenVirtconController_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ OpenVirtconController_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer);
+ ~OpenVirtconController_Impl() = default;
+ OpenVirtconController_Impl(OpenVirtconController_Impl&& other) = default;
+ OpenVirtconController_Impl& operator=(OpenVirtconController_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 OpenController_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ OpenController_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer);
+ ~OpenController_Impl() = default;
+ OpenController_Impl(OpenController_Impl&& other) = default;
+ OpenController_Impl& operator=(OpenController_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 OpenVirtconController = OpenVirtconController_Impl<OpenVirtconControllerResponse>;
+ using OpenController = OpenController_Impl<OpenControllerResponse>;
+ };
+
+ 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_; }
+
+ // Open a virtcon client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a virtcon controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::OpenVirtconController OpenVirtconController(::zx::channel device, ::zx::channel controller);
+
+ // Open a virtcon client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a virtcon controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OpenVirtconController OpenVirtconController(::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer);
+
+ // Open a primary client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a primary controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::OpenController OpenController(::zx::channel device, ::zx::channel controller);
+
+ // Open a primary client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a primary controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OpenController OpenController(::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::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:
+
+ // Open a virtcon client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a virtcon controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::OpenVirtconController OpenVirtconController(::zx::unowned_channel _client_end, ::zx::channel device, ::zx::channel controller);
+
+ // Open a virtcon client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a virtcon controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OpenVirtconController OpenVirtconController(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::fidl::BytePart _response_buffer);
+
+ // Open a primary client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a primary controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::OpenController OpenController(::zx::unowned_channel _client_end, ::zx::channel device, ::zx::channel controller);
+
+ // Open a primary client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a primary controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OpenController OpenController(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device, ::zx::channel controller, ::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:
+
+ // Open a virtcon client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a virtcon controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ static ::fidl::DecodeResult<OpenVirtconControllerResponse> OpenVirtconController(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenVirtconControllerRequest> params, ::fidl::BytePart response_buffer);
+
+ // Open a primary client. `device` should be a handle to one endpoint of a
+ // channel that (on success) will become an open connection to a new
+ // instance of a display client device. A protocol request `controller`
+ // provides an interface to the Controller for the new device. Closing the
+ // connection to `device` will also close the `controller` interface. If
+ // the display device already has a primary controller then this method
+ // will return `ZX_ERR_ALREADY_BOUND`.
+ static ::fidl::DecodeResult<OpenControllerResponse> OpenController(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenControllerRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Provider;
+ using _Base = ::fidl::CompleterBase;
+
+ class OpenVirtconControllerCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<OpenVirtconControllerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using OpenVirtconControllerCompleter = ::fidl::Completer<OpenVirtconControllerCompleterBase>;
+
+ virtual void OpenVirtconController(::zx::channel device, ::zx::channel controller, OpenVirtconControllerCompleter::Sync _completer) = 0;
+
+ class OpenControllerCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<OpenControllerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using OpenControllerCompleter = ::fidl::Completer<OpenControllerCompleterBase>;
+
+ virtual void OpenController(::zx::channel device, ::zx::channel controller, OpenControllerCompleter::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 OpenVirtconControllerRequest(const ::fidl::DecodedMessage<Provider::OpenVirtconControllerRequest>& _msg);
+ static void OpenVirtconControllerResponse(const ::fidl::DecodedMessage<Provider::OpenVirtconControllerResponse>& _msg);
+ static void OpenControllerRequest(const ::fidl::DecodedMessage<Provider::OpenControllerRequest>& _msg);
+ static void OpenControllerResponse(const ::fidl::DecodedMessage<Provider::OpenControllerResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ModeTable;
+
+struct Mode {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ModeTable;
+ 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;
+
+ uint32_t horizontal_resolution = {};
+
+ uint32_t vertical_resolution = {};
+
+ uint32_t refresh_rate_e2 = {};
+
+ uint32_t flags = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_FrameTable;
+
+struct Frame {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_FrameTable;
+ 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;
+
+ uint32_t x_pos = {};
+
+ uint32_t y_pos = {};
+
+ uint32_t width = {};
+
+ uint32_t height = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_CursorInfoTable;
+
+struct CursorInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_CursorInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 12;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t width = {};
+
+ uint32_t height = {};
+
+ uint32_t pixel_format = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_InfoTable;
+
+struct Info {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_InfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 104;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasPointer = true;
+
+ uint64_t id = {};
+
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::display::Mode> modes = {};
+
+ ::fidl::VectorView<uint32_t> pixel_format = {};
+
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::display::CursorInfo> cursor_configs = {};
+
+ ::fidl::StringView manufacturer_name = {};
+
+ ::fidl::StringView monitor_name = {};
+
+ ::fidl::StringView monitor_serial = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_Controller_StartCapture_ResponseTable;
+
+struct Controller_StartCapture_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_Controller_StartCapture_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_Controller_ReleaseCapture_ResponseTable;
+
+struct Controller_ReleaseCapture_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_Controller_ReleaseCapture_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_Controller_IsCaptureSupported_ResponseTable;
+
+struct Controller_IsCaptureSupported_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_Controller_IsCaptureSupported_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ bool supported = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_Controller_ImportImageForCapture_ResponseTable;
+
+struct Controller_ImportImageForCapture_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_Controller_ImportImageForCapture_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t image_id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ClientCompositionOpTable;
+
+struct ClientCompositionOp {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ClientCompositionOpTable;
+ 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 display_id = {};
+
+ uint64_t layer_id = {};
+
+ ::llcpp::fuchsia::hardware::display::ClientCompositionOpcode opcode = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerDisplaysChangedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerDisplaysChangedEventTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportVmoImageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportVmoImageResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportImageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportImageResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseImageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseImageResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerCreateLayerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerCreateLayerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerDestroyLayerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerDestroyLayerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayModeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayColorConversionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayColorConversionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayLayersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetDisplayLayersResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryPositionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryPositionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryAlphaRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerPrimaryAlphaResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerCursorConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerCursorConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerCursorPositionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerCursorPositionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerColorConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerColorConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerImageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetLayerImageResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerCheckConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerCheckConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerApplyConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerApplyConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerEnableVsyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerEnableVsyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerVsyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerVsyncEventTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetVirtconModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetVirtconModeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerClientOwnershipChangeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerClientOwnershipChangeEventTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportBufferCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportBufferCollectionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseBufferCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseBufferCollectionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetBufferCollectionConstraintsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerSetBufferCollectionConstraintsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerGetSingleBufferFramebufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerGetSingleBufferFramebufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerIsCaptureSupportedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerIsCaptureSupportedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportImageForCaptureRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerImportImageForCaptureResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerStartCaptureRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerStartCaptureResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseCaptureRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_display_ControllerReleaseCaptureResponseTable;
+
+// Interface for accessing the display hardware.
+//
+// A display configuration can be separated into two parts: the layer layout and
+// the layer contents. The layout includes all parts of a configuration other
+// than the image handles. The active configuration is composed of the most
+// recently applied layout and an active image from each layer - see
+// SetLayerImage for details on how the active image is defined. Note the
+// requirement that each layer has an active image. Whenever a new active
+// configuration is available, it is immediately given to the hardware. This
+// allows the layout and each layer's contents to advance independently when
+// possible.
+//
+// Performing illegal actions on the interface will result in the interface
+// being closed.
+class Controller final {
+ Controller() = delete;
+ public:
+
+ struct DisplaysChangedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::display::Info> added;
+ ::fidl::VectorView<uint64_t> removed;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerDisplaysChangedEventTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ 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 ImportVmoImageResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t res;
+ uint64_t image_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportVmoImageResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 ImportVmoImageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::display::ImageConfig image_config;
+ ::zx::vmo vmo;
+ int32_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportVmoImageRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = ImportVmoImageResponse;
+ };
+
+ struct ImportImageResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t res;
+ uint64_t image_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportImageResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 ImportImageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::display::ImageConfig image_config;
+ uint64_t collection_id;
+ uint32_t index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportImageRequestTable;
+ 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 = ImportImageResponse;
+ };
+
+ struct ReleaseImageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t image_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerReleaseImageRequestTable;
+ 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;
+ };
+
+ struct ImportEventRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::event event;
+ uint64_t id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportEventRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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;
+ };
+
+ struct ReleaseEventRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerReleaseEventRequestTable;
+ 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;
+ };
+
+ struct CreateLayerResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t res;
+ uint64_t layer_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerCreateLayerResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 CreateLayerRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DestroyLayerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t layer_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerDestroyLayerRequestTable;
+ 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;
+ };
+
+ struct SetDisplayModeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t display_id;
+ ::llcpp::fuchsia::hardware::display::Mode mode;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetDisplayModeRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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;
+ };
+
+ struct SetDisplayColorConversionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t display_id;
+ ::fidl::Array<float, 3> preoffsets;
+ ::fidl::Array<float, 9> coefficients;
+ ::fidl::Array<float, 3> postoffsets;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetDisplayColorConversionRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 88;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 88;
+ 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;
+ };
+
+ struct SetDisplayLayersRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t display_id;
+ ::fidl::VectorView<uint64_t> layer_ids;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetDisplayLayersRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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;
+ };
+
+ struct SetLayerPrimaryConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t layer_id;
+ ::llcpp::fuchsia::hardware::display::ImageConfig image_config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetLayerPrimaryConfigRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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;
+ };
+
+ struct SetLayerPrimaryPositionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t layer_id;
+ ::llcpp::fuchsia::hardware::display::Transform transform;
+ ::llcpp::fuchsia::hardware::display::Frame src_frame;
+ ::llcpp::fuchsia::hardware::display::Frame dest_frame;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetLayerPrimaryPositionRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 64;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 64;
+ 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;
+ };
+
+ struct SetLayerPrimaryAlphaRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t layer_id;
+ ::llcpp::fuchsia::hardware::display::AlphaMode mode;
+ float val;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetLayerPrimaryAlphaRequestTable;
+ 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;
+ };
+
+ struct SetLayerCursorConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t layer_id;
+ ::llcpp::fuchsia::hardware::display::ImageConfig image_config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetLayerCursorConfigRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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;
+ };
+
+ struct SetLayerCursorPositionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t layer_id;
+ int32_t x;
+ int32_t y;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetLayerCursorPositionRequestTable;
+ 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;
+ };
+
+ struct SetLayerColorConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t layer_id;
+ uint32_t pixel_format;
+ ::fidl::VectorView<uint8_t> color_bytes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetLayerColorConfigRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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;
+ };
+
+ struct SetLayerImageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t layer_id;
+ uint64_t image_id;
+ uint64_t wait_event_id;
+ uint64_t signal_event_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetLayerImageRequestTable;
+ 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;
+ };
+
+ struct CheckConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::display::ConfigResult res;
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::display::ClientCompositionOp> ops;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerCheckConfigResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ 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 CheckConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool discard;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerCheckConfigRequestTable;
+ 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 = CheckConfigResponse;
+ };
+
+ using ApplyConfigRequest = ::fidl::AnyZeroArgMessage;
+
+ struct EnableVsyncRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool enable;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerEnableVsyncRequestTable;
+ 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;
+ };
+
+ struct VsyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t display_id;
+ uint64_t timestamp;
+ ::fidl::VectorView<uint64_t> images;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerVsyncEventTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ 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 SetVirtconModeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint8_t mode;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetVirtconModeRequestTable;
+ 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;
+ };
+
+ struct ClientOwnershipChangeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool has_ownership;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerClientOwnershipChangeEventTable;
+ 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 ImportBufferCollectionResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t res;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportBufferCollectionResponseTable;
+ 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 ImportBufferCollectionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t collection_id;
+ ::zx::channel collection_token;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportBufferCollectionRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = ImportBufferCollectionResponse;
+ };
+
+ struct ReleaseBufferCollectionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t collection_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerReleaseBufferCollectionRequestTable;
+ 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;
+ };
+
+ struct SetBufferCollectionConstraintsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t res;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetBufferCollectionConstraintsResponseTable;
+ 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 SetBufferCollectionConstraintsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t collection_id;
+ ::llcpp::fuchsia::hardware::display::ImageConfig config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerSetBufferCollectionConstraintsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = SetBufferCollectionConstraintsResponse;
+ };
+
+ struct GetSingleBufferFramebufferResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t res;
+ ::zx::vmo vmo;
+ uint32_t stride;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerGetSingleBufferFramebufferResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 GetSingleBufferFramebufferRequest = ::fidl::AnyZeroArgMessage;
+
+ struct IsCaptureSupportedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerIsCaptureSupportedResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using IsCaptureSupportedRequest = ::fidl::AnyZeroArgMessage;
+
+ struct ImportImageForCaptureResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportImageForCaptureResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ImportImageForCaptureRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::display::ImageConfig image_config;
+ uint64_t collection_id;
+ uint32_t index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerImportImageForCaptureRequestTable;
+ 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 = ImportImageForCaptureResponse;
+ };
+
+ struct StartCaptureResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::display::Controller_StartCapture_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerStartCaptureResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct StartCaptureRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t signal_event_id;
+ uint64_t image_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerStartCaptureRequestTable;
+ 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 = StartCaptureResponse;
+ };
+
+ struct ReleaseCaptureResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerReleaseCaptureResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ReleaseCaptureRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t image_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_display_ControllerReleaseCaptureRequestTable;
+ 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 = ReleaseCaptureResponse;
+ };
+
+
+ struct EventHandlers {
+ fit::callback<zx_status_t(::fidl::VectorView<::llcpp::fuchsia::hardware::display::Info> added, ::fidl::VectorView<uint64_t> removed)> displays_changed;
+
+ fit::callback<zx_status_t(uint64_t display_id, uint64_t timestamp, ::fidl::VectorView<uint64_t> images)> vsync;
+
+ fit::callback<zx_status_t(bool has_ownership)> client_ownership_change;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class ImportVmoImage_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ImportVmoImage_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset);
+ ~ImportVmoImage_Impl() = default;
+ ImportVmoImage_Impl(ImportVmoImage_Impl&& other) = default;
+ ImportVmoImage_Impl& operator=(ImportVmoImage_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 ImportImage_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ImportImage_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index);
+ ~ImportImage_Impl() = default;
+ ImportImage_Impl(ImportImage_Impl&& other) = default;
+ ImportImage_Impl& operator=(ImportImage_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ReleaseImage_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ReleaseImage_Impl(::zx::unowned_channel _client_end, uint64_t image_id);
+ ~ReleaseImage_Impl() = default;
+ ReleaseImage_Impl(ReleaseImage_Impl&& other) = default;
+ ReleaseImage_Impl& operator=(ReleaseImage_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class ImportEvent_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ImportEvent_Impl(::zx::unowned_channel _client_end, ::zx::event event, uint64_t id);
+ ~ImportEvent_Impl() = default;
+ ImportEvent_Impl(ImportEvent_Impl&& other) = default;
+ ImportEvent_Impl& operator=(ImportEvent_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class ReleaseEvent_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ReleaseEvent_Impl(::zx::unowned_channel _client_end, uint64_t id);
+ ~ReleaseEvent_Impl() = default;
+ ReleaseEvent_Impl(ReleaseEvent_Impl&& other) = default;
+ ReleaseEvent_Impl& operator=(ReleaseEvent_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class CreateLayer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CreateLayer_Impl(::zx::unowned_channel _client_end);
+ ~CreateLayer_Impl() = default;
+ CreateLayer_Impl(CreateLayer_Impl&& other) = default;
+ CreateLayer_Impl& operator=(CreateLayer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class DestroyLayer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ DestroyLayer_Impl(::zx::unowned_channel _client_end, uint64_t layer_id);
+ ~DestroyLayer_Impl() = default;
+ DestroyLayer_Impl(DestroyLayer_Impl&& other) = default;
+ DestroyLayer_Impl& operator=(DestroyLayer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetDisplayMode_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetDisplayMode_Impl(::zx::unowned_channel _client_end, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode);
+ ~SetDisplayMode_Impl() = default;
+ SetDisplayMode_Impl(SetDisplayMode_Impl&& other) = default;
+ SetDisplayMode_Impl& operator=(SetDisplayMode_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetDisplayColorConversion_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetDisplayColorConversion_Impl(::zx::unowned_channel _client_end, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets);
+ ~SetDisplayColorConversion_Impl() = default;
+ SetDisplayColorConversion_Impl(SetDisplayColorConversion_Impl&& other) = default;
+ SetDisplayColorConversion_Impl& operator=(SetDisplayColorConversion_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetDisplayLayers_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetDisplayLayers_Impl(::zx::unowned_channel _client_end, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids);
+ ~SetDisplayLayers_Impl() = default;
+ SetDisplayLayers_Impl(SetDisplayLayers_Impl&& other) = default;
+ SetDisplayLayers_Impl& operator=(SetDisplayLayers_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerPrimaryConfig_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerPrimaryConfig_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+ ~SetLayerPrimaryConfig_Impl() = default;
+ SetLayerPrimaryConfig_Impl(SetLayerPrimaryConfig_Impl&& other) = default;
+ SetLayerPrimaryConfig_Impl& operator=(SetLayerPrimaryConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerPrimaryPosition_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerPrimaryPosition_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame);
+ ~SetLayerPrimaryPosition_Impl() = default;
+ SetLayerPrimaryPosition_Impl(SetLayerPrimaryPosition_Impl&& other) = default;
+ SetLayerPrimaryPosition_Impl& operator=(SetLayerPrimaryPosition_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerPrimaryAlpha_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerPrimaryAlpha_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val);
+ ~SetLayerPrimaryAlpha_Impl() = default;
+ SetLayerPrimaryAlpha_Impl(SetLayerPrimaryAlpha_Impl&& other) = default;
+ SetLayerPrimaryAlpha_Impl& operator=(SetLayerPrimaryAlpha_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerCursorConfig_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerCursorConfig_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+ ~SetLayerCursorConfig_Impl() = default;
+ SetLayerCursorConfig_Impl(SetLayerCursorConfig_Impl&& other) = default;
+ SetLayerCursorConfig_Impl& operator=(SetLayerCursorConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerCursorPosition_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerCursorPosition_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, int32_t x, int32_t y);
+ ~SetLayerCursorPosition_Impl() = default;
+ SetLayerCursorPosition_Impl(SetLayerCursorPosition_Impl&& other) = default;
+ SetLayerCursorPosition_Impl& operator=(SetLayerCursorPosition_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerColorConfig_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerColorConfig_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes);
+ ~SetLayerColorConfig_Impl() = default;
+ SetLayerColorConfig_Impl(SetLayerColorConfig_Impl&& other) = default;
+ SetLayerColorConfig_Impl& operator=(SetLayerColorConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerImage_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerImage_Impl(::zx::unowned_channel _client_end, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id);
+ ~SetLayerImage_Impl() = default;
+ SetLayerImage_Impl(SetLayerImage_Impl&& other) = default;
+ SetLayerImage_Impl& operator=(SetLayerImage_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class CheckConfig_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CheckConfig_Impl(::zx::unowned_channel _client_end, bool discard);
+ ~CheckConfig_Impl() = default;
+ CheckConfig_Impl(CheckConfig_Impl&& other) = default;
+ CheckConfig_Impl& operator=(CheckConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ApplyConfig_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ApplyConfig_Impl(::zx::unowned_channel _client_end);
+ ~ApplyConfig_Impl() = default;
+ ApplyConfig_Impl(ApplyConfig_Impl&& other) = default;
+ ApplyConfig_Impl& operator=(ApplyConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class EnableVsync_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ EnableVsync_Impl(::zx::unowned_channel _client_end, bool enable);
+ ~EnableVsync_Impl() = default;
+ EnableVsync_Impl(EnableVsync_Impl&& other) = default;
+ EnableVsync_Impl& operator=(EnableVsync_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetVirtconMode_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetVirtconMode_Impl(::zx::unowned_channel _client_end, uint8_t mode);
+ ~SetVirtconMode_Impl() = default;
+ SetVirtconMode_Impl(SetVirtconMode_Impl&& other) = default;
+ SetVirtconMode_Impl& operator=(SetVirtconMode_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class ImportBufferCollection_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ImportBufferCollection_Impl(::zx::unowned_channel _client_end, uint64_t collection_id, ::zx::channel collection_token);
+ ~ImportBufferCollection_Impl() = default;
+ ImportBufferCollection_Impl(ImportBufferCollection_Impl&& other) = default;
+ ImportBufferCollection_Impl& operator=(ImportBufferCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ReleaseBufferCollection_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ReleaseBufferCollection_Impl(::zx::unowned_channel _client_end, uint64_t collection_id);
+ ~ReleaseBufferCollection_Impl() = default;
+ ReleaseBufferCollection_Impl(ReleaseBufferCollection_Impl&& other) = default;
+ ReleaseBufferCollection_Impl& operator=(ReleaseBufferCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class SetBufferCollectionConstraints_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetBufferCollectionConstraints_Impl(::zx::unowned_channel _client_end, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config);
+ ~SetBufferCollectionConstraints_Impl() = default;
+ SetBufferCollectionConstraints_Impl(SetBufferCollectionConstraints_Impl&& other) = default;
+ SetBufferCollectionConstraints_Impl& operator=(SetBufferCollectionConstraints_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 GetSingleBufferFramebuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSingleBufferFramebuffer_Impl(::zx::unowned_channel _client_end);
+ ~GetSingleBufferFramebuffer_Impl() = default;
+ GetSingleBufferFramebuffer_Impl(GetSingleBufferFramebuffer_Impl&& other) = default;
+ GetSingleBufferFramebuffer_Impl& operator=(GetSingleBufferFramebuffer_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 IsCaptureSupported_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ IsCaptureSupported_Impl(::zx::unowned_channel _client_end);
+ ~IsCaptureSupported_Impl() = default;
+ IsCaptureSupported_Impl(IsCaptureSupported_Impl&& other) = default;
+ IsCaptureSupported_Impl& operator=(IsCaptureSupported_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 ImportImageForCapture_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ImportImageForCapture_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index);
+ ~ImportImageForCapture_Impl() = default;
+ ImportImageForCapture_Impl(ImportImageForCapture_Impl&& other) = default;
+ ImportImageForCapture_Impl& operator=(ImportImageForCapture_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 StartCapture_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ StartCapture_Impl(::zx::unowned_channel _client_end, uint64_t signal_event_id, uint64_t image_id);
+ ~StartCapture_Impl() = default;
+ StartCapture_Impl(StartCapture_Impl&& other) = default;
+ StartCapture_Impl& operator=(StartCapture_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 ReleaseCapture_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReleaseCapture_Impl(::zx::unowned_channel _client_end, uint64_t image_id);
+ ~ReleaseCapture_Impl() = default;
+ ReleaseCapture_Impl(ReleaseCapture_Impl&& other) = default;
+ ReleaseCapture_Impl& operator=(ReleaseCapture_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 ImportVmoImage = ImportVmoImage_Impl<ImportVmoImageResponse>;
+ using ImportImage = ImportImage_Impl<ImportImageResponse>;
+ using ReleaseImage = ReleaseImage_Impl;
+ using ImportEvent = ImportEvent_Impl;
+ using ReleaseEvent = ReleaseEvent_Impl;
+ using CreateLayer = CreateLayer_Impl<CreateLayerResponse>;
+ using DestroyLayer = DestroyLayer_Impl;
+ using SetDisplayMode = SetDisplayMode_Impl;
+ using SetDisplayColorConversion = SetDisplayColorConversion_Impl;
+ using SetDisplayLayers = SetDisplayLayers_Impl;
+ using SetLayerPrimaryConfig = SetLayerPrimaryConfig_Impl;
+ using SetLayerPrimaryPosition = SetLayerPrimaryPosition_Impl;
+ using SetLayerPrimaryAlpha = SetLayerPrimaryAlpha_Impl;
+ using SetLayerCursorConfig = SetLayerCursorConfig_Impl;
+ using SetLayerCursorPosition = SetLayerCursorPosition_Impl;
+ using SetLayerColorConfig = SetLayerColorConfig_Impl;
+ using SetLayerImage = SetLayerImage_Impl;
+ using CheckConfig = CheckConfig_Impl<CheckConfigResponse>;
+ using ApplyConfig = ApplyConfig_Impl;
+ using EnableVsync = EnableVsync_Impl;
+ using SetVirtconMode = SetVirtconMode_Impl;
+ using ImportBufferCollection = ImportBufferCollection_Impl<ImportBufferCollectionResponse>;
+ using ReleaseBufferCollection = ReleaseBufferCollection_Impl;
+ using SetBufferCollectionConstraints = SetBufferCollectionConstraints_Impl<SetBufferCollectionConstraintsResponse>;
+ using GetSingleBufferFramebuffer = GetSingleBufferFramebuffer_Impl<GetSingleBufferFramebufferResponse>;
+ using IsCaptureSupported = IsCaptureSupported_Impl<IsCaptureSupportedResponse>;
+ using ImportImageForCapture = ImportImageForCapture_Impl<ImportImageForCaptureResponse>;
+ using StartCapture = StartCapture_Impl<StartCaptureResponse>;
+ using ReleaseCapture = ReleaseCapture_Impl<ReleaseCaptureResponse>;
+ };
+
+ // 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 ImportVmoImage_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ImportVmoImage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset, ::fidl::BytePart _response_buffer);
+ ~ImportVmoImage_Impl() = default;
+ ImportVmoImage_Impl(ImportVmoImage_Impl&& other) = default;
+ ImportVmoImage_Impl& operator=(ImportVmoImage_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 ImportImage_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ImportImage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer);
+ ~ImportImage_Impl() = default;
+ ImportImage_Impl(ImportImage_Impl&& other) = default;
+ ImportImage_Impl& operator=(ImportImage_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ReleaseImage_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ReleaseImage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t image_id);
+ ~ReleaseImage_Impl() = default;
+ ReleaseImage_Impl(ReleaseImage_Impl&& other) = default;
+ ReleaseImage_Impl& operator=(ReleaseImage_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class ImportEvent_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ImportEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::event event, uint64_t id);
+ ~ImportEvent_Impl() = default;
+ ImportEvent_Impl(ImportEvent_Impl&& other) = default;
+ ImportEvent_Impl& operator=(ImportEvent_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class ReleaseEvent_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ReleaseEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t id);
+ ~ReleaseEvent_Impl() = default;
+ ReleaseEvent_Impl(ReleaseEvent_Impl&& other) = default;
+ ReleaseEvent_Impl& operator=(ReleaseEvent_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class CreateLayer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CreateLayer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~CreateLayer_Impl() = default;
+ CreateLayer_Impl(CreateLayer_Impl&& other) = default;
+ CreateLayer_Impl& operator=(CreateLayer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class DestroyLayer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ DestroyLayer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id);
+ ~DestroyLayer_Impl() = default;
+ DestroyLayer_Impl(DestroyLayer_Impl&& other) = default;
+ DestroyLayer_Impl& operator=(DestroyLayer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetDisplayMode_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetDisplayMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode);
+ ~SetDisplayMode_Impl() = default;
+ SetDisplayMode_Impl(SetDisplayMode_Impl&& other) = default;
+ SetDisplayMode_Impl& operator=(SetDisplayMode_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetDisplayColorConversion_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetDisplayColorConversion_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets);
+ ~SetDisplayColorConversion_Impl() = default;
+ SetDisplayColorConversion_Impl(SetDisplayColorConversion_Impl&& other) = default;
+ SetDisplayColorConversion_Impl& operator=(SetDisplayColorConversion_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetDisplayLayers_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetDisplayLayers_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids);
+ ~SetDisplayLayers_Impl() = default;
+ SetDisplayLayers_Impl(SetDisplayLayers_Impl&& other) = default;
+ SetDisplayLayers_Impl& operator=(SetDisplayLayers_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerPrimaryConfig_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerPrimaryConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+ ~SetLayerPrimaryConfig_Impl() = default;
+ SetLayerPrimaryConfig_Impl(SetLayerPrimaryConfig_Impl&& other) = default;
+ SetLayerPrimaryConfig_Impl& operator=(SetLayerPrimaryConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerPrimaryPosition_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerPrimaryPosition_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame);
+ ~SetLayerPrimaryPosition_Impl() = default;
+ SetLayerPrimaryPosition_Impl(SetLayerPrimaryPosition_Impl&& other) = default;
+ SetLayerPrimaryPosition_Impl& operator=(SetLayerPrimaryPosition_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerPrimaryAlpha_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerPrimaryAlpha_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val);
+ ~SetLayerPrimaryAlpha_Impl() = default;
+ SetLayerPrimaryAlpha_Impl(SetLayerPrimaryAlpha_Impl&& other) = default;
+ SetLayerPrimaryAlpha_Impl& operator=(SetLayerPrimaryAlpha_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerCursorConfig_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerCursorConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+ ~SetLayerCursorConfig_Impl() = default;
+ SetLayerCursorConfig_Impl(SetLayerCursorConfig_Impl&& other) = default;
+ SetLayerCursorConfig_Impl& operator=(SetLayerCursorConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerCursorPosition_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerCursorPosition_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, int32_t x, int32_t y);
+ ~SetLayerCursorPosition_Impl() = default;
+ SetLayerCursorPosition_Impl(SetLayerCursorPosition_Impl&& other) = default;
+ SetLayerCursorPosition_Impl& operator=(SetLayerCursorPosition_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerColorConfig_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerColorConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes);
+ ~SetLayerColorConfig_Impl() = default;
+ SetLayerColorConfig_Impl(SetLayerColorConfig_Impl&& other) = default;
+ SetLayerColorConfig_Impl& operator=(SetLayerColorConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetLayerImage_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetLayerImage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id);
+ ~SetLayerImage_Impl() = default;
+ SetLayerImage_Impl(SetLayerImage_Impl&& other) = default;
+ SetLayerImage_Impl& operator=(SetLayerImage_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class CheckConfig_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CheckConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool discard, ::fidl::BytePart _response_buffer);
+ ~CheckConfig_Impl() = default;
+ CheckConfig_Impl(CheckConfig_Impl&& other) = default;
+ CheckConfig_Impl& operator=(CheckConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ApplyConfig_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ApplyConfig_Impl(::zx::unowned_channel _client_end);
+ ~ApplyConfig_Impl() = default;
+ ApplyConfig_Impl(ApplyConfig_Impl&& other) = default;
+ ApplyConfig_Impl& operator=(ApplyConfig_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class EnableVsync_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ EnableVsync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable);
+ ~EnableVsync_Impl() = default;
+ EnableVsync_Impl(EnableVsync_Impl&& other) = default;
+ EnableVsync_Impl& operator=(EnableVsync_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class SetVirtconMode_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetVirtconMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t mode);
+ ~SetVirtconMode_Impl() = default;
+ SetVirtconMode_Impl(SetVirtconMode_Impl&& other) = default;
+ SetVirtconMode_Impl& operator=(SetVirtconMode_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class ImportBufferCollection_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ImportBufferCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id, ::zx::channel collection_token, ::fidl::BytePart _response_buffer);
+ ~ImportBufferCollection_Impl() = default;
+ ImportBufferCollection_Impl(ImportBufferCollection_Impl&& other) = default;
+ ImportBufferCollection_Impl& operator=(ImportBufferCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class ReleaseBufferCollection_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ReleaseBufferCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id);
+ ~ReleaseBufferCollection_Impl() = default;
+ ReleaseBufferCollection_Impl(ReleaseBufferCollection_Impl&& other) = default;
+ ReleaseBufferCollection_Impl& operator=(ReleaseBufferCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class SetBufferCollectionConstraints_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetBufferCollectionConstraints_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config, ::fidl::BytePart _response_buffer);
+ ~SetBufferCollectionConstraints_Impl() = default;
+ SetBufferCollectionConstraints_Impl(SetBufferCollectionConstraints_Impl&& other) = default;
+ SetBufferCollectionConstraints_Impl& operator=(SetBufferCollectionConstraints_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 GetSingleBufferFramebuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSingleBufferFramebuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetSingleBufferFramebuffer_Impl() = default;
+ GetSingleBufferFramebuffer_Impl(GetSingleBufferFramebuffer_Impl&& other) = default;
+ GetSingleBufferFramebuffer_Impl& operator=(GetSingleBufferFramebuffer_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 IsCaptureSupported_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ IsCaptureSupported_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~IsCaptureSupported_Impl() = default;
+ IsCaptureSupported_Impl(IsCaptureSupported_Impl&& other) = default;
+ IsCaptureSupported_Impl& operator=(IsCaptureSupported_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 ImportImageForCapture_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ImportImageForCapture_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer);
+ ~ImportImageForCapture_Impl() = default;
+ ImportImageForCapture_Impl(ImportImageForCapture_Impl&& other) = default;
+ ImportImageForCapture_Impl& operator=(ImportImageForCapture_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 StartCapture_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ StartCapture_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t signal_event_id, uint64_t image_id, ::fidl::BytePart _response_buffer);
+ ~StartCapture_Impl() = default;
+ StartCapture_Impl(StartCapture_Impl&& other) = default;
+ StartCapture_Impl& operator=(StartCapture_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 ReleaseCapture_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReleaseCapture_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t image_id, ::fidl::BytePart _response_buffer);
+ ~ReleaseCapture_Impl() = default;
+ ReleaseCapture_Impl(ReleaseCapture_Impl&& other) = default;
+ ReleaseCapture_Impl& operator=(ReleaseCapture_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 ImportVmoImage = ImportVmoImage_Impl<ImportVmoImageResponse>;
+ using ImportImage = ImportImage_Impl<ImportImageResponse>;
+ using ReleaseImage = ReleaseImage_Impl;
+ using ImportEvent = ImportEvent_Impl;
+ using ReleaseEvent = ReleaseEvent_Impl;
+ using CreateLayer = CreateLayer_Impl<CreateLayerResponse>;
+ using DestroyLayer = DestroyLayer_Impl;
+ using SetDisplayMode = SetDisplayMode_Impl;
+ using SetDisplayColorConversion = SetDisplayColorConversion_Impl;
+ using SetDisplayLayers = SetDisplayLayers_Impl;
+ using SetLayerPrimaryConfig = SetLayerPrimaryConfig_Impl;
+ using SetLayerPrimaryPosition = SetLayerPrimaryPosition_Impl;
+ using SetLayerPrimaryAlpha = SetLayerPrimaryAlpha_Impl;
+ using SetLayerCursorConfig = SetLayerCursorConfig_Impl;
+ using SetLayerCursorPosition = SetLayerCursorPosition_Impl;
+ using SetLayerColorConfig = SetLayerColorConfig_Impl;
+ using SetLayerImage = SetLayerImage_Impl;
+ using CheckConfig = CheckConfig_Impl<CheckConfigResponse>;
+ using ApplyConfig = ApplyConfig_Impl;
+ using EnableVsync = EnableVsync_Impl;
+ using SetVirtconMode = SetVirtconMode_Impl;
+ using ImportBufferCollection = ImportBufferCollection_Impl<ImportBufferCollectionResponse>;
+ using ReleaseBufferCollection = ReleaseBufferCollection_Impl;
+ using SetBufferCollectionConstraints = SetBufferCollectionConstraints_Impl<SetBufferCollectionConstraintsResponse>;
+ using GetSingleBufferFramebuffer = GetSingleBufferFramebuffer_Impl<GetSingleBufferFramebufferResponse>;
+ using IsCaptureSupported = IsCaptureSupported_Impl<IsCaptureSupportedResponse>;
+ using ImportImageForCapture = ImportImageForCapture_Impl<ImportImageForCaptureResponse>;
+ using StartCapture = StartCapture_Impl<StartCaptureResponse>;
+ using ReleaseCapture = ReleaseCapture_Impl<ReleaseCaptureResponse>;
+ };
+
+ 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::ImportVmoImage ImportVmoImage(::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ImportVmoImage ImportVmoImage(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset, ::fidl::BytePart _response_buffer);
+
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ImportImage ImportImage(::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ImportImage ImportImage(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReleaseImage ReleaseImage(uint64_t image_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReleaseImage ReleaseImage(::fidl::BytePart _request_buffer, uint64_t image_id);
+
+ // Imports an event into the driver and associates it with the given id.
+ //
+ // It is illegal for id to be equal to invalidId, and it is undefined to
+ // import one event with two different ids or to import two different events
+ // with the same id (note that ids map well to koids).
+ //
+ // If a client is reusing events, they must clear the signal
+ // before referencing the id again.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ImportEvent ImportEvent(::zx::event event, uint64_t id);
+
+ // Imports an event into the driver and associates it with the given id.
+ //
+ // It is illegal for id to be equal to invalidId, and it is undefined to
+ // import one event with two different ids or to import two different events
+ // with the same id (note that ids map well to koids).
+ //
+ // If a client is reusing events, they must clear the signal
+ // before referencing the id again.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ImportEvent ImportEvent(::fidl::BytePart _request_buffer, ::zx::event event, uint64_t id);
+
+ // Releases the event imported with the given id.
+ //
+ // If any images are currently using the given event, the event
+ // will still be waited up or signaled as appropriate before its
+ // resources are released. It is an error to reuse an ID while the
+ // active config has references to it.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReleaseEvent ReleaseEvent(uint64_t id);
+
+ // Releases the event imported with the given id.
+ //
+ // If any images are currently using the given event, the event
+ // will still be waited up or signaled as appropriate before its
+ // resources are released. It is an error to reuse an ID while the
+ // active config has references to it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReleaseEvent ReleaseEvent(::fidl::BytePart _request_buffer, uint64_t id);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateLayer CreateLayer();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateLayer CreateLayer(::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DestroyLayer DestroyLayer(uint64_t layer_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DestroyLayer DestroyLayer(::fidl::BytePart _request_buffer, uint64_t layer_id);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetDisplayMode SetDisplayMode(uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetDisplayMode SetDisplayMode(::fidl::BytePart _request_buffer, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode);
+
+ // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetDisplayColorConversion SetDisplayColorConversion(uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetDisplayColorConversion SetDisplayColorConversion(::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets);
+
+ // Request is heap-allocated.
+ ResultOf::SetDisplayLayers SetDisplayLayers(uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetDisplayLayers SetDisplayLayers(::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetLayerPrimaryConfig SetLayerPrimaryConfig(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetLayerPrimaryConfig SetLayerPrimaryConfig(::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetLayerPrimaryPosition SetLayerPrimaryPosition(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetLayerPrimaryPosition SetLayerPrimaryPosition(::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame);
+
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetLayerPrimaryAlpha SetLayerPrimaryAlpha(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetLayerPrimaryAlpha SetLayerPrimaryAlpha(::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetLayerCursorConfig SetLayerCursorConfig(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetLayerCursorConfig SetLayerCursorConfig(::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetLayerCursorPosition SetLayerCursorPosition(uint64_t layer_id, int32_t x, int32_t y);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetLayerCursorPosition SetLayerCursorPosition(::fidl::BytePart _request_buffer, uint64_t layer_id, int32_t x, int32_t y);
+
+ // Request is heap-allocated.
+ ResultOf::SetLayerColorConfig SetLayerColorConfig(uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetLayerColorConfig SetLayerColorConfig(::fidl::BytePart _request_buffer, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetLayerImage SetLayerImage(uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetLayerImage SetLayerImage(::fidl::BytePart _request_buffer, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id);
+
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::CheckConfig CheckConfig(bool discard);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CheckConfig CheckConfig(::fidl::BytePart _request_buffer, bool discard, ::fidl::BytePart _response_buffer);
+
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ApplyConfig ApplyConfig();
+
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::EnableVsync EnableVsync(bool enable);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::EnableVsync EnableVsync(::fidl::BytePart _request_buffer, bool enable);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetVirtconMode SetVirtconMode(uint8_t mode);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetVirtconMode SetVirtconMode(::fidl::BytePart _request_buffer, uint8_t mode);
+
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ImportBufferCollection ImportBufferCollection(uint64_t collection_id, ::zx::channel collection_token);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ImportBufferCollection ImportBufferCollection(::fidl::BytePart _request_buffer, uint64_t collection_id, ::zx::channel collection_token, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReleaseBufferCollection ReleaseBufferCollection(uint64_t collection_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReleaseBufferCollection ReleaseBufferCollection(::fidl::BytePart _request_buffer, uint64_t collection_id);
+
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetBufferCollectionConstraints SetBufferCollectionConstraints(uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetBufferCollectionConstraints SetBufferCollectionConstraints(::fidl::BytePart _request_buffer, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetSingleBufferFramebuffer GetSingleBufferFramebuffer();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSingleBufferFramebuffer GetSingleBufferFramebuffer(::fidl::BytePart _response_buffer);
+
+ // Returns true if Capture is supported on the platform.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::IsCaptureSupported IsCaptureSupported();
+
+ // Returns true if Capture is supported on the platform.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::IsCaptureSupported IsCaptureSupported(::fidl::BytePart _response_buffer);
+
+ // Imports a buffer collection backed VMO into the display controller. The VMO
+ // will be used by display controller to capture the image being displayed.
+ // Returns ZX_OK along with an image_id.
+ // image_id must be used by the client to start capture and/or release
+ // resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ImportImageForCapture ImportImageForCapture(::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index);
+
+ // Imports a buffer collection backed VMO into the display controller. The VMO
+ // will be used by display controller to capture the image being displayed.
+ // Returns ZX_OK along with an image_id.
+ // image_id must be used by the client to start capture and/or release
+ // resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ImportImageForCapture ImportImageForCapture(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Starts capture. Client must provide a valid signal_event_id and
+ // image_id. signal_event_id must have been imported into the driver
+ // using ImportEvent FIDL API. Image_id is the id from ImportImageForCapture.
+ // The client will get notified once capture is complete via signal_event_id.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::StartCapture StartCapture(uint64_t signal_event_id, uint64_t image_id);
+
+ // Starts capture. Client must provide a valid signal_event_id and
+ // image_id. signal_event_id must have been imported into the driver
+ // using ImportEvent FIDL API. Image_id is the id from ImportImageForCapture.
+ // The client will get notified once capture is complete via signal_event_id.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::StartCapture StartCapture(::fidl::BytePart _request_buffer, uint64_t signal_event_id, uint64_t image_id, ::fidl::BytePart _response_buffer);
+
+ // Releases resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReleaseCapture ReleaseCapture(uint64_t image_id);
+
+ // Releases resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReleaseCapture ReleaseCapture(::fidl::BytePart _request_buffer, uint64_t image_id, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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::ImportVmoImage ImportVmoImage(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ImportVmoImage ImportVmoImage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset, ::fidl::BytePart _response_buffer);
+
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ImportImage ImportImage(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ImportImage ImportImage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReleaseImage ReleaseImage(::zx::unowned_channel _client_end, uint64_t image_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReleaseImage ReleaseImage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t image_id);
+
+ // Imports an event into the driver and associates it with the given id.
+ //
+ // It is illegal for id to be equal to invalidId, and it is undefined to
+ // import one event with two different ids or to import two different events
+ // with the same id (note that ids map well to koids).
+ //
+ // If a client is reusing events, they must clear the signal
+ // before referencing the id again.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ImportEvent ImportEvent(::zx::unowned_channel _client_end, ::zx::event event, uint64_t id);
+
+ // Imports an event into the driver and associates it with the given id.
+ //
+ // It is illegal for id to be equal to invalidId, and it is undefined to
+ // import one event with two different ids or to import two different events
+ // with the same id (note that ids map well to koids).
+ //
+ // If a client is reusing events, they must clear the signal
+ // before referencing the id again.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ImportEvent ImportEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::event event, uint64_t id);
+
+ // Releases the event imported with the given id.
+ //
+ // If any images are currently using the given event, the event
+ // will still be waited up or signaled as appropriate before its
+ // resources are released. It is an error to reuse an ID while the
+ // active config has references to it.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReleaseEvent ReleaseEvent(::zx::unowned_channel _client_end, uint64_t id);
+
+ // Releases the event imported with the given id.
+ //
+ // If any images are currently using the given event, the event
+ // will still be waited up or signaled as appropriate before its
+ // resources are released. It is an error to reuse an ID while the
+ // active config has references to it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReleaseEvent ReleaseEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t id);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateLayer CreateLayer(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateLayer CreateLayer(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DestroyLayer DestroyLayer(::zx::unowned_channel _client_end, uint64_t layer_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DestroyLayer DestroyLayer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetDisplayMode SetDisplayMode(::zx::unowned_channel _client_end, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetDisplayMode SetDisplayMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode);
+
+ // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetDisplayColorConversion SetDisplayColorConversion(::zx::unowned_channel _client_end, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetDisplayColorConversion SetDisplayColorConversion(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets);
+
+ // Request is heap-allocated.
+ static ResultOf::SetDisplayLayers SetDisplayLayers(::zx::unowned_channel _client_end, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetDisplayLayers SetDisplayLayers(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetLayerPrimaryConfig SetLayerPrimaryConfig(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetLayerPrimaryConfig SetLayerPrimaryConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetLayerPrimaryPosition SetLayerPrimaryPosition(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetLayerPrimaryPosition SetLayerPrimaryPosition(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame);
+
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetLayerPrimaryAlpha SetLayerPrimaryAlpha(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetLayerPrimaryAlpha SetLayerPrimaryAlpha(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetLayerCursorConfig SetLayerCursorConfig(::zx::unowned_channel _client_end, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetLayerCursorConfig SetLayerCursorConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config);
+
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetLayerCursorPosition SetLayerCursorPosition(::zx::unowned_channel _client_end, uint64_t layer_id, int32_t x, int32_t y);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetLayerCursorPosition SetLayerCursorPosition(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, int32_t x, int32_t y);
+
+ // Request is heap-allocated.
+ static ResultOf::SetLayerColorConfig SetLayerColorConfig(::zx::unowned_channel _client_end, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetLayerColorConfig SetLayerColorConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetLayerImage SetLayerImage(::zx::unowned_channel _client_end, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetLayerImage SetLayerImage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id);
+
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::CheckConfig CheckConfig(::zx::unowned_channel _client_end, bool discard);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CheckConfig CheckConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool discard, ::fidl::BytePart _response_buffer);
+
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ApplyConfig ApplyConfig(::zx::unowned_channel _client_end);
+
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::EnableVsync EnableVsync(::zx::unowned_channel _client_end, bool enable);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::EnableVsync EnableVsync(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetVirtconMode SetVirtconMode(::zx::unowned_channel _client_end, uint8_t mode);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetVirtconMode SetVirtconMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t mode);
+
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ImportBufferCollection ImportBufferCollection(::zx::unowned_channel _client_end, uint64_t collection_id, ::zx::channel collection_token);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ImportBufferCollection ImportBufferCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id, ::zx::channel collection_token, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReleaseBufferCollection ReleaseBufferCollection(::zx::unowned_channel _client_end, uint64_t collection_id);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReleaseBufferCollection ReleaseBufferCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id);
+
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetBufferCollectionConstraints SetBufferCollectionConstraints(::zx::unowned_channel _client_end, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetBufferCollectionConstraints SetBufferCollectionConstraints(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetSingleBufferFramebuffer GetSingleBufferFramebuffer(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSingleBufferFramebuffer GetSingleBufferFramebuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns true if Capture is supported on the platform.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::IsCaptureSupported IsCaptureSupported(::zx::unowned_channel _client_end);
+
+ // Returns true if Capture is supported on the platform.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::IsCaptureSupported IsCaptureSupported(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Imports a buffer collection backed VMO into the display controller. The VMO
+ // will be used by display controller to capture the image being displayed.
+ // Returns ZX_OK along with an image_id.
+ // image_id must be used by the client to start capture and/or release
+ // resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ImportImageForCapture ImportImageForCapture(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index);
+
+ // Imports a buffer collection backed VMO into the display controller. The VMO
+ // will be used by display controller to capture the image being displayed.
+ // Returns ZX_OK along with an image_id.
+ // image_id must be used by the client to start capture and/or release
+ // resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ImportImageForCapture ImportImageForCapture(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Starts capture. Client must provide a valid signal_event_id and
+ // image_id. signal_event_id must have been imported into the driver
+ // using ImportEvent FIDL API. Image_id is the id from ImportImageForCapture.
+ // The client will get notified once capture is complete via signal_event_id.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::StartCapture StartCapture(::zx::unowned_channel _client_end, uint64_t signal_event_id, uint64_t image_id);
+
+ // Starts capture. Client must provide a valid signal_event_id and
+ // image_id. signal_event_id must have been imported into the driver
+ // using ImportEvent FIDL API. Image_id is the id from ImportImageForCapture.
+ // The client will get notified once capture is complete via signal_event_id.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::StartCapture StartCapture(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t signal_event_id, uint64_t image_id, ::fidl::BytePart _response_buffer);
+
+ // Releases resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReleaseCapture ReleaseCapture(::zx::unowned_channel _client_end, uint64_t image_id);
+
+ // Releases resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReleaseCapture ReleaseCapture(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t image_id, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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<ImportVmoImageResponse> ImportVmoImage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportVmoImageRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ImportImageResponse> ImportImage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportImageRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::internal::StatusAndError ReleaseImage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseImageRequest> params);
+
+ // Imports an event into the driver and associates it with the given id.
+ //
+ // It is illegal for id to be equal to invalidId, and it is undefined to
+ // import one event with two different ids or to import two different events
+ // with the same id (note that ids map well to koids).
+ //
+ // If a client is reusing events, they must clear the signal
+ // before referencing the id again.
+ static ::fidl::internal::StatusAndError ImportEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportEventRequest> params);
+
+ // Releases the event imported with the given id.
+ //
+ // If any images are currently using the given event, the event
+ // will still be waited up or signaled as appropriate before its
+ // resources are released. It is an error to reuse an ID while the
+ // active config has references to it.
+ static ::fidl::internal::StatusAndError ReleaseEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseEventRequest> params);
+
+ static ::fidl::DecodeResult<CreateLayerResponse> CreateLayer(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::internal::StatusAndError DestroyLayer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DestroyLayerRequest> params);
+
+ static ::fidl::internal::StatusAndError SetDisplayMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDisplayModeRequest> params);
+
+ static ::fidl::internal::StatusAndError SetDisplayColorConversion(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDisplayColorConversionRequest> params);
+
+ static ::fidl::internal::StatusAndError SetDisplayLayers(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDisplayLayersRequest> params);
+
+ static ::fidl::internal::StatusAndError SetLayerPrimaryConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerPrimaryConfigRequest> params);
+
+ static ::fidl::internal::StatusAndError SetLayerPrimaryPosition(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerPrimaryPositionRequest> params);
+
+ static ::fidl::internal::StatusAndError SetLayerPrimaryAlpha(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerPrimaryAlphaRequest> params);
+
+ static ::fidl::internal::StatusAndError SetLayerCursorConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerCursorConfigRequest> params);
+
+ static ::fidl::internal::StatusAndError SetLayerCursorPosition(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerCursorPositionRequest> params);
+
+ static ::fidl::internal::StatusAndError SetLayerColorConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerColorConfigRequest> params);
+
+ static ::fidl::internal::StatusAndError SetLayerImage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetLayerImageRequest> params);
+
+ static ::fidl::DecodeResult<CheckConfigResponse> CheckConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CheckConfigRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::internal::StatusAndError ApplyConfig(::zx::unowned_channel _client_end);
+
+ static ::fidl::internal::StatusAndError EnableVsync(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EnableVsyncRequest> params);
+
+ static ::fidl::internal::StatusAndError SetVirtconMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetVirtconModeRequest> params);
+
+ static ::fidl::DecodeResult<ImportBufferCollectionResponse> ImportBufferCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportBufferCollectionRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::internal::StatusAndError ReleaseBufferCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseBufferCollectionRequest> params);
+
+ static ::fidl::DecodeResult<SetBufferCollectionConstraintsResponse> SetBufferCollectionConstraints(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetBufferCollectionConstraintsRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetSingleBufferFramebufferResponse> GetSingleBufferFramebuffer(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns true if Capture is supported on the platform.
+ static ::fidl::DecodeResult<IsCaptureSupportedResponse> IsCaptureSupported(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Imports a buffer collection backed VMO into the display controller. The VMO
+ // will be used by display controller to capture the image being displayed.
+ // Returns ZX_OK along with an image_id.
+ // image_id must be used by the client to start capture and/or release
+ // resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ static ::fidl::DecodeResult<ImportImageForCaptureResponse> ImportImageForCapture(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ImportImageForCaptureRequest> params, ::fidl::BytePart response_buffer);
+
+ // Starts capture. Client must provide a valid signal_event_id and
+ // image_id. signal_event_id must have been imported into the driver
+ // using ImportEvent FIDL API. Image_id is the id from ImportImageForCapture.
+ // The client will get notified once capture is complete via signal_event_id.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ static ::fidl::DecodeResult<StartCaptureResponse> StartCapture(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StartCaptureRequest> params, ::fidl::BytePart response_buffer);
+
+ // Releases resources allocated for capture.
+ // Returns ZX_ERR_NOT_SUPPORTED if controller does not support capture
+ static ::fidl::DecodeResult<ReleaseCaptureResponse> ReleaseCapture(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReleaseCaptureRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Controller;
+ using _Base = ::fidl::CompleterBase;
+
+ class ImportVmoImageCompleterBase : public _Base {
+ public:
+ void Reply(int32_t res, uint64_t image_id);
+ void Reply(::fidl::BytePart _buffer, int32_t res, uint64_t image_id);
+ void Reply(::fidl::DecodedMessage<ImportVmoImageResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ImportVmoImageCompleter = ::fidl::Completer<ImportVmoImageCompleterBase>;
+
+ virtual void ImportVmoImage(::llcpp::fuchsia::hardware::display::ImageConfig image_config, ::zx::vmo vmo, int32_t offset, ImportVmoImageCompleter::Sync _completer) = 0;
+
+ class ImportImageCompleterBase : public _Base {
+ public:
+ void Reply(int32_t res, uint64_t image_id);
+ void Reply(::fidl::BytePart _buffer, int32_t res, uint64_t image_id);
+ void Reply(::fidl::DecodedMessage<ImportImageResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ImportImageCompleter = ::fidl::Completer<ImportImageCompleterBase>;
+
+ virtual void ImportImage(::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ImportImageCompleter::Sync _completer) = 0;
+
+ using ReleaseImageCompleter = ::fidl::Completer<>;
+
+ virtual void ReleaseImage(uint64_t image_id, ReleaseImageCompleter::Sync _completer) = 0;
+
+ using ImportEventCompleter = ::fidl::Completer<>;
+
+ virtual void ImportEvent(::zx::event event, uint64_t id, ImportEventCompleter::Sync _completer) = 0;
+
+ using ReleaseEventCompleter = ::fidl::Completer<>;
+
+ virtual void ReleaseEvent(uint64_t id, ReleaseEventCompleter::Sync _completer) = 0;
+
+ class CreateLayerCompleterBase : public _Base {
+ public:
+ void Reply(int32_t res, uint64_t layer_id);
+ void Reply(::fidl::BytePart _buffer, int32_t res, uint64_t layer_id);
+ void Reply(::fidl::DecodedMessage<CreateLayerResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CreateLayerCompleter = ::fidl::Completer<CreateLayerCompleterBase>;
+
+ virtual void CreateLayer(CreateLayerCompleter::Sync _completer) = 0;
+
+ using DestroyLayerCompleter = ::fidl::Completer<>;
+
+ virtual void DestroyLayer(uint64_t layer_id, DestroyLayerCompleter::Sync _completer) = 0;
+
+ using SetDisplayModeCompleter = ::fidl::Completer<>;
+
+ virtual void SetDisplayMode(uint64_t display_id, ::llcpp::fuchsia::hardware::display::Mode mode, SetDisplayModeCompleter::Sync _completer) = 0;
+
+ using SetDisplayColorConversionCompleter = ::fidl::Completer<>;
+
+ virtual void SetDisplayColorConversion(uint64_t display_id, ::fidl::Array<float, 3> preoffsets, ::fidl::Array<float, 9> coefficients, ::fidl::Array<float, 3> postoffsets, SetDisplayColorConversionCompleter::Sync _completer) = 0;
+
+ using SetDisplayLayersCompleter = ::fidl::Completer<>;
+
+ virtual void SetDisplayLayers(uint64_t display_id, ::fidl::VectorView<uint64_t> layer_ids, SetDisplayLayersCompleter::Sync _completer) = 0;
+
+ using SetLayerPrimaryConfigCompleter = ::fidl::Completer<>;
+
+ virtual void SetLayerPrimaryConfig(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, SetLayerPrimaryConfigCompleter::Sync _completer) = 0;
+
+ using SetLayerPrimaryPositionCompleter = ::fidl::Completer<>;
+
+ virtual void SetLayerPrimaryPosition(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::Transform transform, ::llcpp::fuchsia::hardware::display::Frame src_frame, ::llcpp::fuchsia::hardware::display::Frame dest_frame, SetLayerPrimaryPositionCompleter::Sync _completer) = 0;
+
+ using SetLayerPrimaryAlphaCompleter = ::fidl::Completer<>;
+
+ virtual void SetLayerPrimaryAlpha(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::AlphaMode mode, float val, SetLayerPrimaryAlphaCompleter::Sync _completer) = 0;
+
+ using SetLayerCursorConfigCompleter = ::fidl::Completer<>;
+
+ virtual void SetLayerCursorConfig(uint64_t layer_id, ::llcpp::fuchsia::hardware::display::ImageConfig image_config, SetLayerCursorConfigCompleter::Sync _completer) = 0;
+
+ using SetLayerCursorPositionCompleter = ::fidl::Completer<>;
+
+ virtual void SetLayerCursorPosition(uint64_t layer_id, int32_t x, int32_t y, SetLayerCursorPositionCompleter::Sync _completer) = 0;
+
+ using SetLayerColorConfigCompleter = ::fidl::Completer<>;
+
+ virtual void SetLayerColorConfig(uint64_t layer_id, uint32_t pixel_format, ::fidl::VectorView<uint8_t> color_bytes, SetLayerColorConfigCompleter::Sync _completer) = 0;
+
+ using SetLayerImageCompleter = ::fidl::Completer<>;
+
+ virtual void SetLayerImage(uint64_t layer_id, uint64_t image_id, uint64_t wait_event_id, uint64_t signal_event_id, SetLayerImageCompleter::Sync _completer) = 0;
+
+ class CheckConfigCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::display::ConfigResult res, ::fidl::VectorView<::llcpp::fuchsia::hardware::display::ClientCompositionOp> ops);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::ConfigResult res, ::fidl::VectorView<::llcpp::fuchsia::hardware::display::ClientCompositionOp> ops);
+ void Reply(::fidl::DecodedMessage<CheckConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CheckConfigCompleter = ::fidl::Completer<CheckConfigCompleterBase>;
+
+ virtual void CheckConfig(bool discard, CheckConfigCompleter::Sync _completer) = 0;
+
+ using ApplyConfigCompleter = ::fidl::Completer<>;
+
+ virtual void ApplyConfig(ApplyConfigCompleter::Sync _completer) = 0;
+
+ using EnableVsyncCompleter = ::fidl::Completer<>;
+
+ virtual void EnableVsync(bool enable, EnableVsyncCompleter::Sync _completer) = 0;
+
+ using SetVirtconModeCompleter = ::fidl::Completer<>;
+
+ virtual void SetVirtconMode(uint8_t mode, SetVirtconModeCompleter::Sync _completer) = 0;
+
+ class ImportBufferCollectionCompleterBase : public _Base {
+ public:
+ void Reply(int32_t res);
+ void Reply(::fidl::BytePart _buffer, int32_t res);
+ void Reply(::fidl::DecodedMessage<ImportBufferCollectionResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ImportBufferCollectionCompleter = ::fidl::Completer<ImportBufferCollectionCompleterBase>;
+
+ virtual void ImportBufferCollection(uint64_t collection_id, ::zx::channel collection_token, ImportBufferCollectionCompleter::Sync _completer) = 0;
+
+ using ReleaseBufferCollectionCompleter = ::fidl::Completer<>;
+
+ virtual void ReleaseBufferCollection(uint64_t collection_id, ReleaseBufferCollectionCompleter::Sync _completer) = 0;
+
+ class SetBufferCollectionConstraintsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t res);
+ void Reply(::fidl::BytePart _buffer, int32_t res);
+ void Reply(::fidl::DecodedMessage<SetBufferCollectionConstraintsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetBufferCollectionConstraintsCompleter = ::fidl::Completer<SetBufferCollectionConstraintsCompleterBase>;
+
+ virtual void SetBufferCollectionConstraints(uint64_t collection_id, ::llcpp::fuchsia::hardware::display::ImageConfig config, SetBufferCollectionConstraintsCompleter::Sync _completer) = 0;
+
+ class GetSingleBufferFramebufferCompleterBase : public _Base {
+ public:
+ void Reply(int32_t res, ::zx::vmo vmo, uint32_t stride);
+ void Reply(::fidl::BytePart _buffer, int32_t res, ::zx::vmo vmo, uint32_t stride);
+ void Reply(::fidl::DecodedMessage<GetSingleBufferFramebufferResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSingleBufferFramebufferCompleter = ::fidl::Completer<GetSingleBufferFramebufferCompleterBase>;
+
+ virtual void GetSingleBufferFramebuffer(GetSingleBufferFramebufferCompleter::Sync _completer) = 0;
+
+ class IsCaptureSupportedCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Result result);
+ void ReplySuccess(bool supported);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, bool supported);
+ void Reply(::fidl::DecodedMessage<IsCaptureSupportedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using IsCaptureSupportedCompleter = ::fidl::Completer<IsCaptureSupportedCompleterBase>;
+
+ virtual void IsCaptureSupported(IsCaptureSupportedCompleter::Sync _completer) = 0;
+
+ class ImportImageForCaptureCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Result result);
+ void ReplySuccess(uint64_t image_id);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint64_t image_id);
+ void Reply(::fidl::DecodedMessage<ImportImageForCaptureResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ImportImageForCaptureCompleter = ::fidl::Completer<ImportImageForCaptureCompleterBase>;
+
+ virtual void ImportImageForCapture(::llcpp::fuchsia::hardware::display::ImageConfig image_config, uint64_t collection_id, uint32_t index, ImportImageForCaptureCompleter::Sync _completer) = 0;
+
+ class StartCaptureCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::display::Controller_StartCapture_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::Controller_StartCapture_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<StartCaptureResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StartCaptureCompleter = ::fidl::Completer<StartCaptureCompleterBase>;
+
+ virtual void StartCapture(uint64_t signal_event_id, uint64_t image_id, StartCaptureCompleter::Sync _completer) = 0;
+
+ class ReleaseCaptureCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ReleaseCaptureResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReleaseCaptureCompleter = ::fidl::Completer<ReleaseCaptureCompleterBase>;
+
+ virtual void ReleaseCapture(uint64_t image_id, ReleaseCaptureCompleter::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);
+ }
+
+ static zx_status_t SendDisplaysChangedEvent(::zx::unowned_channel _chan, ::fidl::VectorView<::llcpp::fuchsia::hardware::display::Info> added, ::fidl::VectorView<uint64_t> removed);
+
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendDisplaysChangedEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::hardware::display::Info> added, ::fidl::VectorView<uint64_t> removed);
+
+ // Messages are encoded in-place.
+ static zx_status_t SendDisplaysChangedEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<DisplaysChangedResponse> params);
+
+ static zx_status_t SendVsyncEvent(::zx::unowned_channel _chan, uint64_t display_id, uint64_t timestamp, ::fidl::VectorView<uint64_t> images);
+
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendVsyncEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, uint64_t display_id, uint64_t timestamp, ::fidl::VectorView<uint64_t> images);
+
+ // Messages are encoded in-place.
+ static zx_status_t SendVsyncEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<VsyncResponse> params);
+
+ static zx_status_t SendClientOwnershipChangeEvent(::zx::unowned_channel _chan, bool has_ownership);
+
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendClientOwnershipChangeEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, bool has_ownership);
+
+ // Messages are encoded in-place.
+ static zx_status_t SendClientOwnershipChangeEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<ClientOwnershipChangeResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void DisplaysChangedResponse(const ::fidl::DecodedMessage<Controller::DisplaysChangedResponse>& _msg);
+ static void ImportVmoImageRequest(const ::fidl::DecodedMessage<Controller::ImportVmoImageRequest>& _msg);
+ static void ImportVmoImageResponse(const ::fidl::DecodedMessage<Controller::ImportVmoImageResponse>& _msg);
+ static void ImportImageRequest(const ::fidl::DecodedMessage<Controller::ImportImageRequest>& _msg);
+ static void ImportImageResponse(const ::fidl::DecodedMessage<Controller::ImportImageResponse>& _msg);
+ static void ReleaseImageRequest(const ::fidl::DecodedMessage<Controller::ReleaseImageRequest>& _msg);
+ static void ImportEventRequest(const ::fidl::DecodedMessage<Controller::ImportEventRequest>& _msg);
+ static void ReleaseEventRequest(const ::fidl::DecodedMessage<Controller::ReleaseEventRequest>& _msg);
+ static void CreateLayerRequest(const ::fidl::DecodedMessage<Controller::CreateLayerRequest>& _msg);
+ static void CreateLayerResponse(const ::fidl::DecodedMessage<Controller::CreateLayerResponse>& _msg);
+ static void DestroyLayerRequest(const ::fidl::DecodedMessage<Controller::DestroyLayerRequest>& _msg);
+ static void SetDisplayModeRequest(const ::fidl::DecodedMessage<Controller::SetDisplayModeRequest>& _msg);
+ static void SetDisplayColorConversionRequest(const ::fidl::DecodedMessage<Controller::SetDisplayColorConversionRequest>& _msg);
+ static void SetDisplayLayersRequest(const ::fidl::DecodedMessage<Controller::SetDisplayLayersRequest>& _msg);
+ static void SetLayerPrimaryConfigRequest(const ::fidl::DecodedMessage<Controller::SetLayerPrimaryConfigRequest>& _msg);
+ static void SetLayerPrimaryPositionRequest(const ::fidl::DecodedMessage<Controller::SetLayerPrimaryPositionRequest>& _msg);
+ static void SetLayerPrimaryAlphaRequest(const ::fidl::DecodedMessage<Controller::SetLayerPrimaryAlphaRequest>& _msg);
+ static void SetLayerCursorConfigRequest(const ::fidl::DecodedMessage<Controller::SetLayerCursorConfigRequest>& _msg);
+ static void SetLayerCursorPositionRequest(const ::fidl::DecodedMessage<Controller::SetLayerCursorPositionRequest>& _msg);
+ static void SetLayerColorConfigRequest(const ::fidl::DecodedMessage<Controller::SetLayerColorConfigRequest>& _msg);
+ static void SetLayerImageRequest(const ::fidl::DecodedMessage<Controller::SetLayerImageRequest>& _msg);
+ static void CheckConfigRequest(const ::fidl::DecodedMessage<Controller::CheckConfigRequest>& _msg);
+ static void CheckConfigResponse(const ::fidl::DecodedMessage<Controller::CheckConfigResponse>& _msg);
+ static void ApplyConfigRequest(const ::fidl::DecodedMessage<Controller::ApplyConfigRequest>& _msg);
+ static void EnableVsyncRequest(const ::fidl::DecodedMessage<Controller::EnableVsyncRequest>& _msg);
+ static void VsyncResponse(const ::fidl::DecodedMessage<Controller::VsyncResponse>& _msg);
+ static void SetVirtconModeRequest(const ::fidl::DecodedMessage<Controller::SetVirtconModeRequest>& _msg);
+ static void ClientOwnershipChangeResponse(const ::fidl::DecodedMessage<Controller::ClientOwnershipChangeResponse>& _msg);
+ static void ImportBufferCollectionRequest(const ::fidl::DecodedMessage<Controller::ImportBufferCollectionRequest>& _msg);
+ static void ImportBufferCollectionResponse(const ::fidl::DecodedMessage<Controller::ImportBufferCollectionResponse>& _msg);
+ static void ReleaseBufferCollectionRequest(const ::fidl::DecodedMessage<Controller::ReleaseBufferCollectionRequest>& _msg);
+ static void SetBufferCollectionConstraintsRequest(const ::fidl::DecodedMessage<Controller::SetBufferCollectionConstraintsRequest>& _msg);
+ static void SetBufferCollectionConstraintsResponse(const ::fidl::DecodedMessage<Controller::SetBufferCollectionConstraintsResponse>& _msg);
+ static void GetSingleBufferFramebufferRequest(const ::fidl::DecodedMessage<Controller::GetSingleBufferFramebufferRequest>& _msg);
+ static void GetSingleBufferFramebufferResponse(const ::fidl::DecodedMessage<Controller::GetSingleBufferFramebufferResponse>& _msg);
+ static void IsCaptureSupportedRequest(const ::fidl::DecodedMessage<Controller::IsCaptureSupportedRequest>& _msg);
+ static void IsCaptureSupportedResponse(const ::fidl::DecodedMessage<Controller::IsCaptureSupportedResponse>& _msg);
+ static void ImportImageForCaptureRequest(const ::fidl::DecodedMessage<Controller::ImportImageForCaptureRequest>& _msg);
+ static void ImportImageForCaptureResponse(const ::fidl::DecodedMessage<Controller::ImportImageForCaptureResponse>& _msg);
+ static void StartCaptureRequest(const ::fidl::DecodedMessage<Controller::StartCaptureRequest>& _msg);
+ static void StartCaptureResponse(const ::fidl::DecodedMessage<Controller::StartCaptureResponse>& _msg);
+ static void ReleaseCaptureRequest(const ::fidl::DecodedMessage<Controller::ReleaseCaptureRequest>& _msg);
+ static void ReleaseCaptureResponse(const ::fidl::DecodedMessage<Controller::ReleaseCaptureResponse>& _msg);
+ };
+};
+
+} // namespace display
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::ImageConfig> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::ImageConfig>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::ImageConfig, width) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::ImageConfig, height) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::ImageConfig, pixel_format) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::ImageConfig, type) == 12);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::ImageConfig) == ::llcpp::fuchsia::hardware::display::ImageConfig::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerRequest)
+ == ::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerRequest, device) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerRequest, controller) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerResponse)
+ == ::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Provider::OpenVirtconControllerResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Provider::OpenControllerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Provider::OpenControllerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Provider::OpenControllerRequest)
+ == ::llcpp::fuchsia::hardware::display::Provider::OpenControllerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Provider::OpenControllerRequest, device) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Provider::OpenControllerRequest, controller) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Provider::OpenControllerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Provider::OpenControllerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Provider::OpenControllerResponse)
+ == ::llcpp::fuchsia::hardware::display::Provider::OpenControllerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Provider::OpenControllerResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Mode> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Mode>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Mode, horizontal_resolution) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Mode, vertical_resolution) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Mode, refresh_rate_e2) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Mode, flags) == 12);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Mode) == ::llcpp::fuchsia::hardware::display::Mode::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Frame> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Frame>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Frame, x_pos) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Frame, y_pos) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Frame, width) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Frame, height) == 12);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Frame) == ::llcpp::fuchsia::hardware::display::Frame::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::CursorInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::CursorInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::CursorInfo, width) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::CursorInfo, height) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::CursorInfo, pixel_format) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::CursorInfo) == ::llcpp::fuchsia::hardware::display::CursorInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Info> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Info>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Info, id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Info, modes) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Info, pixel_format) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Info, cursor_configs) == 40);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Info, manufacturer_name) == 56);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Info, monitor_name) == 72);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Info, monitor_serial) == 88);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Info) == ::llcpp::fuchsia::hardware::display::Info::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response) == ::llcpp::fuchsia::hardware::display::Controller_StartCapture_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller_StartCapture_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Controller_StartCapture_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response) == ::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Controller_ReleaseCapture_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response, supported) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response) == ::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Controller_IsCaptureSupported_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response, image_id) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response) == ::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::Controller_ImportImageForCapture_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::ClientCompositionOp> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::display::ClientCompositionOp>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::ClientCompositionOp, display_id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::ClientCompositionOp, layer_id) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::ClientCompositionOp, opcode) == 16);
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::ClientCompositionOp) == ::llcpp::fuchsia::hardware::display::ClientCompositionOp::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::DisplaysChangedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::DisplaysChangedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::DisplaysChangedResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::DisplaysChangedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::DisplaysChangedResponse, added) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::DisplaysChangedResponse, removed) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageRequest, image_config) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageRequest, vmo) == 32);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageRequest, offset) == 36);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageResponse, res) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportVmoImageResponse, image_id) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportImageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportImageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportImageRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportImageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageRequest, image_config) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageRequest, collection_id) == 32);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageRequest, index) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportImageResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportImageResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportImageResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportImageResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageResponse, res) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageResponse, image_id) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ReleaseImageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ReleaseImageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ReleaseImageRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ReleaseImageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ReleaseImageRequest, image_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportEventRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportEventRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportEventRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportEventRequest, event) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportEventRequest, id) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ReleaseEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ReleaseEventRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ReleaseEventRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ReleaseEventRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ReleaseEventRequest, id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::CreateLayerResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::CreateLayerResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::CreateLayerResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::CreateLayerResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::CreateLayerResponse, res) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::CreateLayerResponse, layer_id) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::DestroyLayerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::DestroyLayerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::DestroyLayerRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::DestroyLayerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::DestroyLayerRequest, layer_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetDisplayModeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetDisplayModeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayModeRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetDisplayModeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayModeRequest, display_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayModeRequest, mode) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetDisplayColorConversionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetDisplayColorConversionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayColorConversionRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetDisplayColorConversionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayColorConversionRequest, display_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayColorConversionRequest, preoffsets) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayColorConversionRequest, coefficients) == 36);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayColorConversionRequest, postoffsets) == 72);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetDisplayLayersRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetDisplayLayersRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayLayersRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetDisplayLayersRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayLayersRequest, display_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetDisplayLayersRequest, layer_ids) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryConfigRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryConfigRequest, layer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryConfigRequest, image_config) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryPositionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryPositionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryPositionRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryPositionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryPositionRequest, layer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryPositionRequest, transform) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryPositionRequest, src_frame) == 28);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryPositionRequest, dest_frame) == 44);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryAlphaRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryAlphaRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryAlphaRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryAlphaRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryAlphaRequest, layer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryAlphaRequest, mode) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerPrimaryAlphaRequest, val) == 28);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorConfigRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorConfigRequest, layer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorConfigRequest, image_config) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorPositionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorPositionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorPositionRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorPositionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorPositionRequest, layer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorPositionRequest, x) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerCursorPositionRequest, y) == 28);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetLayerColorConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetLayerColorConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetLayerColorConfigRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetLayerColorConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerColorConfigRequest, layer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerColorConfigRequest, pixel_format) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerColorConfigRequest, color_bytes) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetLayerImageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetLayerImageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetLayerImageRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetLayerImageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerImageRequest, layer_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerImageRequest, image_id) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerImageRequest, wait_event_id) == 32);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetLayerImageRequest, signal_event_id) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::CheckConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::CheckConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::CheckConfigRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::CheckConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::CheckConfigRequest, discard) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::CheckConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::CheckConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::CheckConfigResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::CheckConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::CheckConfigResponse, res) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::CheckConfigResponse, ops) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::EnableVsyncRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::EnableVsyncRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::EnableVsyncRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::EnableVsyncRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::EnableVsyncRequest, enable) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::VsyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::VsyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::VsyncResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::VsyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::VsyncResponse, display_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::VsyncResponse, timestamp) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::VsyncResponse, images) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetVirtconModeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetVirtconModeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetVirtconModeRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetVirtconModeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetVirtconModeRequest, mode) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ClientOwnershipChangeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ClientOwnershipChangeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ClientOwnershipChangeResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::ClientOwnershipChangeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ClientOwnershipChangeResponse, has_ownership) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionRequest, collection_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionRequest, collection_token) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportBufferCollectionResponse, res) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ReleaseBufferCollectionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ReleaseBufferCollectionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ReleaseBufferCollectionRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ReleaseBufferCollectionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ReleaseBufferCollectionRequest, collection_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsRequest, collection_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsRequest, config) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::SetBufferCollectionConstraintsResponse, res) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::GetSingleBufferFramebufferResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::GetSingleBufferFramebufferResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::GetSingleBufferFramebufferResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::GetSingleBufferFramebufferResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::GetSingleBufferFramebufferResponse, res) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::GetSingleBufferFramebufferResponse, vmo) == 20);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::GetSingleBufferFramebufferResponse, stride) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::IsCaptureSupportedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::IsCaptureSupportedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::IsCaptureSupportedResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::IsCaptureSupportedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::IsCaptureSupportedResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureRequest, image_config) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureRequest, collection_id) == 32);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureRequest, index) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ImportImageForCaptureResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::StartCaptureRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::StartCaptureRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::StartCaptureRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::StartCaptureRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::StartCaptureRequest, signal_event_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::StartCaptureRequest, image_id) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::StartCaptureResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::StartCaptureResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::StartCaptureResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::StartCaptureResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::StartCaptureResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureRequest)
+ == ::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureRequest, image_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureResponse)
+ == ::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::display::Controller::ReleaseCaptureResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-ethernet/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-ethernet/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..da0443a
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-ethernet/gen/llcpp/fidl.cc
@@ -0,0 +1,1856 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/ethernet/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace ethernet {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetInfo_Ordinal = 0x10c7deb400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetInfo_GenOrdinal = 0x7f8e9a8dda706422lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetFifos_Ordinal = 0x21e1e8f800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetFifos_GenOrdinal = 0x57924e13bf602360lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetFifosRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetFifosResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetIOBuffer_Ordinal = 0x201df7f300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetIOBuffer_GenOrdinal = 0x66af0a45e326fda8lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetIOBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetIOBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Start_Ordinal = 0x23db365900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Start_GenOrdinal = 0x6e59b9bb7123be35lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceStartResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Stop_Ordinal = 0x3dfcfe9500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Stop_GenOrdinal = 0x4bea699d7725dffblu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceStopResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ListenStart_Ordinal = 0x5b2495bb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ListenStart_GenOrdinal = 0x2825d26aac1495dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceListenStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceListenStartResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ListenStop_Ordinal = 0x236b1c5700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ListenStop_GenOrdinal = 0x102cbf5639c2403alu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceListenStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceListenStopResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetClientName_Ordinal = 0x640c922100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetClientName_GenOrdinal = 0x16226cf5bfe3a001lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetClientNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetClientNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStatus_Ordinal = 0x6d63b33e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStatus_GenOrdinal = 0x379a5ed530acd140lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetStatusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetStatusResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetPromiscuousMode_Ordinal = 0x34c1970400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetPromiscuousMode_GenOrdinal = 0x6ae9e4516810f945lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetPromiscuousModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetPromiscuousModeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ConfigMulticastAddMac_Ordinal = 0x39fce1800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ConfigMulticastAddMac_GenOrdinal = 0x5cdb4b0bd52337b8lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastAddMacRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastAddMacResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ConfigMulticastDeleteMac_Ordinal = 0x51dadb9d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ConfigMulticastDeleteMac_GenOrdinal = 0x540f49129d9bfa07lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastDeleteMacRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastDeleteMacResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ConfigMulticastSetPromiscuousMode_Ordinal = 0x2ab48ffa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ConfigMulticastSetPromiscuousMode_GenOrdinal = 0x53d4ba4a14dbe91alu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousModeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ConfigMulticastTestFilter_Ordinal = 0x54b616e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ConfigMulticastTestFilter_GenOrdinal = 0x5a83a0ecc3d952a3lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastTestFilterRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastTestFilterResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_DumpRegisters_Ordinal = 0x5dd3c8c100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_DumpRegisters_GenOrdinal = 0x43a8fb0535f81274lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceDumpRegistersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceDumpRegistersResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetInfo_Impl<Device::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetInfo Device::SyncClient::GetInfo() {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetInfo Device::Call::GetInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInfo(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetInfo_Impl<Device::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetInfo Device::SyncClient::GetInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetInfo Device::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetInfoResponse> Device::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInfoRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetFifos_Impl<Device::GetFifosResponse>::GetFifos_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFifosRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFifosRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFifosRequest));
+ ::fidl::DecodedMessage<GetFifosRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetFifos(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetFifos Device::SyncClient::GetFifos() {
+ return ResultOf::GetFifos(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetFifos Device::Call::GetFifos(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFifos(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetFifos_Impl<Device::GetFifosResponse>::GetFifos_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFifosRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFifosRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFifosRequest));
+ ::fidl::DecodedMessage<GetFifosRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetFifos(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetFifos Device::SyncClient::GetFifos(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFifos(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetFifos Device::Call::GetFifos(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFifos(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetFifosResponse> Device::InPlace::GetFifos(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFifosRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFifosRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetFifosRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetFifosResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFifosRequest, GetFifosResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetFifosResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetIOBuffer_Impl<Device::SetIOBufferResponse>::SetIOBuffer_Impl(::zx::unowned_channel _client_end, ::zx::vmo h) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetIOBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetIOBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetIOBufferRequest*>(_write_bytes);
+ _request.h = std::move(h);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetIOBufferRequest));
+ ::fidl::DecodedMessage<SetIOBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetIOBuffer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetIOBuffer Device::SyncClient::SetIOBuffer(::zx::vmo h) {
+ return ResultOf::SetIOBuffer(::zx::unowned_channel(this->channel_), std::move(h));
+}
+
+Device::ResultOf::SetIOBuffer Device::Call::SetIOBuffer(::zx::unowned_channel _client_end, ::zx::vmo h) {
+ return ResultOf::SetIOBuffer(std::move(_client_end), std::move(h));
+}
+
+template <>
+Device::UnownedResultOf::SetIOBuffer_Impl<Device::SetIOBufferResponse>::SetIOBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo h, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetIOBufferRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetIOBufferResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetIOBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetIOBufferRequest*>(_request_buffer.data());
+ _request.h = std::move(h);
+ _request_buffer.set_actual(sizeof(SetIOBufferRequest));
+ ::fidl::DecodedMessage<SetIOBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetIOBuffer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetIOBuffer Device::SyncClient::SetIOBuffer(::fidl::BytePart _request_buffer, ::zx::vmo h, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetIOBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(h), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetIOBuffer Device::Call::SetIOBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo h, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetIOBuffer(std::move(_client_end), std::move(_request_buffer), std::move(h), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetIOBufferResponse> Device::InPlace::SetIOBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetIOBufferRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetIOBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetIOBufferResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetIOBufferRequest, SetIOBufferResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetIOBufferResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Start_Impl<Device::StartResponse>::Start_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StartRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartRequest));
+ ::fidl::DecodedMessage<StartRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Start(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::Start Device::SyncClient::Start() {
+ return ResultOf::Start(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::Start Device::Call::Start(::zx::unowned_channel _client_end) {
+ return ResultOf::Start(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::Start_Impl<Device::StartResponse>::Start_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(StartRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, StartRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(StartRequest));
+ ::fidl::DecodedMessage<StartRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::Start(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Start Device::SyncClient::Start(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Start(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Start Device::Call::Start(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Start(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::StartResponse> Device::InPlace::Start(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(StartRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<StartRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::StartRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::StartResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StartRequest, StartResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::StartResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Stop_Impl<Device::StopResponse>::Stop_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StopRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StopRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StopRequest));
+ ::fidl::DecodedMessage<StopRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Stop(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::Stop Device::SyncClient::Stop() {
+ return ResultOf::Stop(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::Stop Device::Call::Stop(::zx::unowned_channel _client_end) {
+ return ResultOf::Stop(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Device::StopResponse> Device::InPlace::Stop(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(StopRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<StopRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::StopRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::StopResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StopRequest, StopResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::StopResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ListenStart_Impl<Device::ListenStartResponse>::ListenStart_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ListenStartRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ListenStartRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ListenStartRequest));
+ ::fidl::DecodedMessage<ListenStartRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ListenStart(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::ListenStart Device::SyncClient::ListenStart() {
+ return ResultOf::ListenStart(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::ListenStart Device::Call::ListenStart(::zx::unowned_channel _client_end) {
+ return ResultOf::ListenStart(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::ListenStart_Impl<Device::ListenStartResponse>::ListenStart_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ListenStartRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ListenStartRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ListenStartRequest));
+ ::fidl::DecodedMessage<ListenStartRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::ListenStart(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::ListenStart Device::SyncClient::ListenStart(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ListenStart(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::ListenStart Device::Call::ListenStart(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ListenStart(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ListenStartResponse> Device::InPlace::ListenStart(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ListenStartRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ListenStartRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::ListenStartRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ListenStartResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ListenStartRequest, ListenStartResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ListenStartResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ListenStop_Impl<Device::ListenStopResponse>::ListenStop_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ListenStopRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ListenStopRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ListenStopRequest));
+ ::fidl::DecodedMessage<ListenStopRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ListenStop(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::ListenStop Device::SyncClient::ListenStop() {
+ return ResultOf::ListenStop(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::ListenStop Device::Call::ListenStop(::zx::unowned_channel _client_end) {
+ return ResultOf::ListenStop(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Device::ListenStopResponse> Device::InPlace::ListenStop(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ListenStopRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ListenStopRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::ListenStopRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ListenStopResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ListenStopRequest, ListenStopResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ListenStopResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetClientName_Impl<Device::SetClientNameResponse>::SetClientName_Impl(::zx::unowned_channel _client_end, ::fidl::StringView name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetClientNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ SetClientNameRequest _request = {};
+ _request.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetClientNameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::SetClientName(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetClientName Device::SyncClient::SetClientName(::fidl::StringView name) {
+ return ResultOf::SetClientName(::zx::unowned_channel(this->channel_), std::move(name));
+}
+
+Device::ResultOf::SetClientName Device::Call::SetClientName(::zx::unowned_channel _client_end, ::fidl::StringView name) {
+ return ResultOf::SetClientName(std::move(_client_end), std::move(name));
+}
+
+template <>
+Device::UnownedResultOf::SetClientName_Impl<Device::SetClientNameResponse>::SetClientName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetClientNameRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetClientNameResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetClientNameRequest _request = {};
+ _request.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetClientNameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::SetClientName(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetClientName Device::SyncClient::SetClientName(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetClientName(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(name), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetClientName Device::Call::SetClientName(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetClientName(std::move(_client_end), std::move(_request_buffer), std::move(name), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetClientNameResponse> Device::InPlace::SetClientName(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetClientNameRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetClientNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetClientNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetClientNameRequest, SetClientNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetClientNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetStatus_Impl<Device::GetStatusResponse>::GetStatus_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatusRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStatusRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStatusRequest));
+ ::fidl::DecodedMessage<GetStatusRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetStatus(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetStatus Device::SyncClient::GetStatus() {
+ return ResultOf::GetStatus(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetStatus Device::Call::GetStatus(::zx::unowned_channel _client_end) {
+ return ResultOf::GetStatus(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetStatus_Impl<Device::GetStatusResponse>::GetStatus_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetStatusRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetStatusRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetStatusRequest));
+ ::fidl::DecodedMessage<GetStatusRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetStatus(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetStatus Device::SyncClient::GetStatus(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStatus(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetStatus Device::Call::GetStatus(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStatus(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetStatusResponse> Device::InPlace::GetStatus(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetStatusRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetStatusRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetStatusRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStatusResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStatusRequest, GetStatusResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStatusResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetPromiscuousMode_Impl<Device::SetPromiscuousModeResponse>::SetPromiscuousMode_Impl(::zx::unowned_channel _client_end, bool enabled) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetPromiscuousModeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetPromiscuousModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetPromiscuousModeRequest*>(_write_bytes);
+ _request.enabled = std::move(enabled);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetPromiscuousModeRequest));
+ ::fidl::DecodedMessage<SetPromiscuousModeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetPromiscuousMode(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetPromiscuousMode Device::SyncClient::SetPromiscuousMode(bool enabled) {
+ return ResultOf::SetPromiscuousMode(::zx::unowned_channel(this->channel_), std::move(enabled));
+}
+
+Device::ResultOf::SetPromiscuousMode Device::Call::SetPromiscuousMode(::zx::unowned_channel _client_end, bool enabled) {
+ return ResultOf::SetPromiscuousMode(std::move(_client_end), std::move(enabled));
+}
+
+template <>
+Device::UnownedResultOf::SetPromiscuousMode_Impl<Device::SetPromiscuousModeResponse>::SetPromiscuousMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetPromiscuousModeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetPromiscuousModeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetPromiscuousModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetPromiscuousModeRequest*>(_request_buffer.data());
+ _request.enabled = std::move(enabled);
+ _request_buffer.set_actual(sizeof(SetPromiscuousModeRequest));
+ ::fidl::DecodedMessage<SetPromiscuousModeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetPromiscuousMode(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetPromiscuousMode Device::SyncClient::SetPromiscuousMode(::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetPromiscuousMode(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetPromiscuousMode Device::Call::SetPromiscuousMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetPromiscuousMode(std::move(_client_end), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetPromiscuousModeResponse> Device::InPlace::SetPromiscuousMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPromiscuousModeRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetPromiscuousModeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetPromiscuousModeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetPromiscuousModeRequest, SetPromiscuousModeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetPromiscuousModeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ConfigMulticastAddMac_Impl<Device::ConfigMulticastAddMacResponse>::ConfigMulticastAddMac_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigMulticastAddMacRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConfigMulticastAddMacRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConfigMulticastAddMacRequest*>(_write_bytes);
+ _request.addr = std::move(addr);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigMulticastAddMacRequest));
+ ::fidl::DecodedMessage<ConfigMulticastAddMacRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ConfigMulticastAddMac(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::ConfigMulticastAddMac Device::SyncClient::ConfigMulticastAddMac(::llcpp::fuchsia::hardware::ethernet::MacAddress addr) {
+ return ResultOf::ConfigMulticastAddMac(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+Device::ResultOf::ConfigMulticastAddMac Device::Call::ConfigMulticastAddMac(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr) {
+ return ResultOf::ConfigMulticastAddMac(std::move(_client_end), std::move(addr));
+}
+
+template <>
+Device::UnownedResultOf::ConfigMulticastAddMac_Impl<Device::ConfigMulticastAddMacResponse>::ConfigMulticastAddMac_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConfigMulticastAddMacRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConfigMulticastAddMacResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ConfigMulticastAddMacRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConfigMulticastAddMacRequest*>(_request_buffer.data());
+ _request.addr = std::move(addr);
+ _request_buffer.set_actual(sizeof(ConfigMulticastAddMacRequest));
+ ::fidl::DecodedMessage<ConfigMulticastAddMacRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::ConfigMulticastAddMac(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::ConfigMulticastAddMac Device::SyncClient::ConfigMulticastAddMac(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigMulticastAddMac(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::ConfigMulticastAddMac Device::Call::ConfigMulticastAddMac(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigMulticastAddMac(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ConfigMulticastAddMacResponse> Device::InPlace::ConfigMulticastAddMac(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigMulticastAddMacRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::ConfigMulticastAddMacRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ConfigMulticastAddMacResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConfigMulticastAddMacRequest, ConfigMulticastAddMacResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ConfigMulticastAddMacResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ConfigMulticastDeleteMac_Impl<Device::ConfigMulticastDeleteMacResponse>::ConfigMulticastDeleteMac_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigMulticastDeleteMacRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConfigMulticastDeleteMacRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConfigMulticastDeleteMacRequest*>(_write_bytes);
+ _request.addr = std::move(addr);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigMulticastDeleteMacRequest));
+ ::fidl::DecodedMessage<ConfigMulticastDeleteMacRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ConfigMulticastDeleteMac(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::ConfigMulticastDeleteMac Device::SyncClient::ConfigMulticastDeleteMac(::llcpp::fuchsia::hardware::ethernet::MacAddress addr) {
+ return ResultOf::ConfigMulticastDeleteMac(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+Device::ResultOf::ConfigMulticastDeleteMac Device::Call::ConfigMulticastDeleteMac(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr) {
+ return ResultOf::ConfigMulticastDeleteMac(std::move(_client_end), std::move(addr));
+}
+
+template <>
+Device::UnownedResultOf::ConfigMulticastDeleteMac_Impl<Device::ConfigMulticastDeleteMacResponse>::ConfigMulticastDeleteMac_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConfigMulticastDeleteMacRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConfigMulticastDeleteMacResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ConfigMulticastDeleteMacRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConfigMulticastDeleteMacRequest*>(_request_buffer.data());
+ _request.addr = std::move(addr);
+ _request_buffer.set_actual(sizeof(ConfigMulticastDeleteMacRequest));
+ ::fidl::DecodedMessage<ConfigMulticastDeleteMacRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::ConfigMulticastDeleteMac(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::ConfigMulticastDeleteMac Device::SyncClient::ConfigMulticastDeleteMac(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigMulticastDeleteMac(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::ConfigMulticastDeleteMac Device::Call::ConfigMulticastDeleteMac(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigMulticastDeleteMac(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ConfigMulticastDeleteMacResponse> Device::InPlace::ConfigMulticastDeleteMac(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigMulticastDeleteMacRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::ConfigMulticastDeleteMacRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ConfigMulticastDeleteMacResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConfigMulticastDeleteMacRequest, ConfigMulticastDeleteMacResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ConfigMulticastDeleteMacResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ConfigMulticastSetPromiscuousMode_Impl<Device::ConfigMulticastSetPromiscuousModeResponse>::ConfigMulticastSetPromiscuousMode_Impl(::zx::unowned_channel _client_end, bool enabled) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigMulticastSetPromiscuousModeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConfigMulticastSetPromiscuousModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConfigMulticastSetPromiscuousModeRequest*>(_write_bytes);
+ _request.enabled = std::move(enabled);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigMulticastSetPromiscuousModeRequest));
+ ::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ConfigMulticastSetPromiscuousMode(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::ConfigMulticastSetPromiscuousMode Device::SyncClient::ConfigMulticastSetPromiscuousMode(bool enabled) {
+ return ResultOf::ConfigMulticastSetPromiscuousMode(::zx::unowned_channel(this->channel_), std::move(enabled));
+}
+
+Device::ResultOf::ConfigMulticastSetPromiscuousMode Device::Call::ConfigMulticastSetPromiscuousMode(::zx::unowned_channel _client_end, bool enabled) {
+ return ResultOf::ConfigMulticastSetPromiscuousMode(std::move(_client_end), std::move(enabled));
+}
+
+template <>
+Device::UnownedResultOf::ConfigMulticastSetPromiscuousMode_Impl<Device::ConfigMulticastSetPromiscuousModeResponse>::ConfigMulticastSetPromiscuousMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConfigMulticastSetPromiscuousModeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConfigMulticastSetPromiscuousModeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ConfigMulticastSetPromiscuousModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConfigMulticastSetPromiscuousModeRequest*>(_request_buffer.data());
+ _request.enabled = std::move(enabled);
+ _request_buffer.set_actual(sizeof(ConfigMulticastSetPromiscuousModeRequest));
+ ::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::ConfigMulticastSetPromiscuousMode(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::ConfigMulticastSetPromiscuousMode Device::SyncClient::ConfigMulticastSetPromiscuousMode(::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigMulticastSetPromiscuousMode(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::ConfigMulticastSetPromiscuousMode Device::Call::ConfigMulticastSetPromiscuousMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigMulticastSetPromiscuousMode(std::move(_client_end), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ConfigMulticastSetPromiscuousModeResponse> Device::InPlace::ConfigMulticastSetPromiscuousMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::ConfigMulticastSetPromiscuousModeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ConfigMulticastSetPromiscuousModeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConfigMulticastSetPromiscuousModeRequest, ConfigMulticastSetPromiscuousModeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ConfigMulticastSetPromiscuousModeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ConfigMulticastTestFilter_Impl<Device::ConfigMulticastTestFilterResponse>::ConfigMulticastTestFilter_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigMulticastTestFilterRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConfigMulticastTestFilterRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigMulticastTestFilterRequest));
+ ::fidl::DecodedMessage<ConfigMulticastTestFilterRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ConfigMulticastTestFilter(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::ConfigMulticastTestFilter Device::SyncClient::ConfigMulticastTestFilter() {
+ return ResultOf::ConfigMulticastTestFilter(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::ConfigMulticastTestFilter Device::Call::ConfigMulticastTestFilter(::zx::unowned_channel _client_end) {
+ return ResultOf::ConfigMulticastTestFilter(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::ConfigMulticastTestFilter_Impl<Device::ConfigMulticastTestFilterResponse>::ConfigMulticastTestFilter_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ConfigMulticastTestFilterRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ConfigMulticastTestFilterRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ConfigMulticastTestFilterRequest));
+ ::fidl::DecodedMessage<ConfigMulticastTestFilterRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::ConfigMulticastTestFilter(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::ConfigMulticastTestFilter Device::SyncClient::ConfigMulticastTestFilter(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigMulticastTestFilter(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::ConfigMulticastTestFilter Device::Call::ConfigMulticastTestFilter(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConfigMulticastTestFilter(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ConfigMulticastTestFilterResponse> Device::InPlace::ConfigMulticastTestFilter(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ConfigMulticastTestFilterRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ConfigMulticastTestFilterRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::ConfigMulticastTestFilterRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ConfigMulticastTestFilterResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConfigMulticastTestFilterRequest, ConfigMulticastTestFilterResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ConfigMulticastTestFilterResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::DumpRegisters_Impl<Device::DumpRegistersResponse>::DumpRegisters_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpRegistersRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DumpRegistersRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpRegistersRequest));
+ ::fidl::DecodedMessage<DumpRegistersRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::DumpRegisters(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::DumpRegisters Device::SyncClient::DumpRegisters() {
+ return ResultOf::DumpRegisters(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::DumpRegisters Device::Call::DumpRegisters(::zx::unowned_channel _client_end) {
+ return ResultOf::DumpRegisters(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::DumpRegisters_Impl<Device::DumpRegistersResponse>::DumpRegisters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DumpRegistersRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DumpRegistersRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DumpRegistersRequest));
+ ::fidl::DecodedMessage<DumpRegistersRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::DumpRegisters(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::DumpRegisters Device::SyncClient::DumpRegisters(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DumpRegisters(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::DumpRegisters Device::Call::DumpRegisters(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DumpRegisters(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::DumpRegistersResponse> Device::InPlace::DumpRegisters(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DumpRegistersRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DumpRegistersRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::DumpRegistersRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::DumpRegistersResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DumpRegistersRequest, DumpRegistersResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::DumpRegistersResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetInfo_Ordinal:
+ case kDevice_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInfo(
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetFifos_Ordinal:
+ case kDevice_GetFifos_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFifosRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFifos(
+ Interface::GetFifosCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetIOBuffer_Ordinal:
+ case kDevice_SetIOBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetIOBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetIOBuffer(std::move(message->h),
+ Interface::SetIOBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Start_Ordinal:
+ case kDevice_Start_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StartRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Start(
+ Interface::StartCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Stop_Ordinal:
+ case kDevice_Stop_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StopRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Stop(
+ Interface::StopCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ListenStart_Ordinal:
+ case kDevice_ListenStart_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ListenStartRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ListenStart(
+ Interface::ListenStartCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ListenStop_Ordinal:
+ case kDevice_ListenStop_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ListenStopRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ListenStop(
+ Interface::ListenStopCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetClientName_Ordinal:
+ case kDevice_SetClientName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetClientNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetClientName(std::move(message->name),
+ Interface::SetClientNameCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetStatus_Ordinal:
+ case kDevice_GetStatus_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStatusRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetStatus(
+ Interface::GetStatusCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetPromiscuousMode_Ordinal:
+ case kDevice_SetPromiscuousMode_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetPromiscuousModeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetPromiscuousMode(std::move(message->enabled),
+ Interface::SetPromiscuousModeCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ConfigMulticastAddMac_Ordinal:
+ case kDevice_ConfigMulticastAddMac_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConfigMulticastAddMacRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ConfigMulticastAddMac(std::move(message->addr),
+ Interface::ConfigMulticastAddMacCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ConfigMulticastDeleteMac_Ordinal:
+ case kDevice_ConfigMulticastDeleteMac_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConfigMulticastDeleteMacRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ConfigMulticastDeleteMac(std::move(message->addr),
+ Interface::ConfigMulticastDeleteMacCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ConfigMulticastSetPromiscuousMode_Ordinal:
+ case kDevice_ConfigMulticastSetPromiscuousMode_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConfigMulticastSetPromiscuousModeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ConfigMulticastSetPromiscuousMode(std::move(message->enabled),
+ Interface::ConfigMulticastSetPromiscuousModeCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ConfigMulticastTestFilter_Ordinal:
+ case kDevice_ConfigMulticastTestFilter_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConfigMulticastTestFilterRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ConfigMulticastTestFilter(
+ Interface::ConfigMulticastTestFilterCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_DumpRegisters_Ordinal:
+ case kDevice_DumpRegisters_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DumpRegistersRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->DumpRegisters(
+ Interface::DumpRegistersCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetInfoCompleterBase::Reply(::llcpp::fuchsia::hardware::ethernet::Info info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetInfoResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetInfoResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::ethernet::Info info) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetInfoResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ _buffer.set_actual(sizeof(GetInfoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetInfoResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ Device::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetFifosCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::ethernet::Fifos* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFifosResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetFifosResponse _response = {};
+ Device::SetTransactionHeaderFor::GetFifosResponse(
+ ::fidl::DecodedMessage<GetFifosResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFifosResponse::PrimarySize,
+ GetFifosResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetFifosCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::ethernet::Fifos* info) {
+ if (_buffer.capacity() < GetFifosResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetFifosResponse _response = {};
+ Device::SetTransactionHeaderFor::GetFifosResponse(
+ ::fidl::DecodedMessage<GetFifosResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFifosResponse::PrimarySize,
+ GetFifosResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetFifosCompleterBase::Reply(::fidl::DecodedMessage<GetFifosResponse> params) {
+ Device::SetTransactionHeaderFor::GetFifosResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetIOBufferCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetIOBufferResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetIOBufferResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetIOBufferResponse(
+ ::fidl::DecodedMessage<SetIOBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetIOBufferResponse::PrimarySize,
+ SetIOBufferResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetIOBufferResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetIOBufferResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetIOBufferCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetIOBufferResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetIOBufferResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetIOBufferResponse(
+ ::fidl::DecodedMessage<SetIOBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetIOBufferResponse::PrimarySize,
+ SetIOBufferResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetIOBufferResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetIOBufferResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetIOBufferCompleterBase::Reply(::fidl::DecodedMessage<SetIOBufferResponse> params) {
+ Device::SetTransactionHeaderFor::SetIOBufferResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::StartCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StartResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::StartResponse(
+ ::fidl::DecodedMessage<StartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartResponse::PrimarySize,
+ StartResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::StartCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < StartResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<StartResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::StartResponse(
+ ::fidl::DecodedMessage<StartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartResponse::PrimarySize,
+ StartResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(StartResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StartResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::StartCompleterBase::Reply(::fidl::DecodedMessage<StartResponse> params) {
+ Device::SetTransactionHeaderFor::StartResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::StopCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StopResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StopResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::StopResponse(
+ ::fidl::DecodedMessage<StopResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StopResponse::PrimarySize,
+ StopResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StopResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StopResponse>(std::move(_response_bytes)));
+}
+
+
+void Device::Interface::ListenStartCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ListenStartResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ListenStartResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ListenStartResponse(
+ ::fidl::DecodedMessage<ListenStartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ListenStartResponse::PrimarySize,
+ ListenStartResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ListenStartResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ListenStartResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::ListenStartCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ListenStartResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ListenStartResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::ListenStartResponse(
+ ::fidl::DecodedMessage<ListenStartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ListenStartResponse::PrimarySize,
+ ListenStartResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ListenStartResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ListenStartResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::ListenStartCompleterBase::Reply(::fidl::DecodedMessage<ListenStartResponse> params) {
+ Device::SetTransactionHeaderFor::ListenStartResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ListenStopCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ListenStopResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ListenStopResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ListenStopResponse(
+ ::fidl::DecodedMessage<ListenStopResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ListenStopResponse::PrimarySize,
+ ListenStopResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ListenStopResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ListenStopResponse>(std::move(_response_bytes)));
+}
+
+
+void Device::Interface::SetClientNameCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetClientNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetClientNameResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetClientNameResponse(
+ ::fidl::DecodedMessage<SetClientNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetClientNameResponse::PrimarySize,
+ SetClientNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetClientNameResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetClientNameResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetClientNameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetClientNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetClientNameResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetClientNameResponse(
+ ::fidl::DecodedMessage<SetClientNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetClientNameResponse::PrimarySize,
+ SetClientNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetClientNameResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetClientNameResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetClientNameCompleterBase::Reply(::fidl::DecodedMessage<SetClientNameResponse> params) {
+ Device::SetTransactionHeaderFor::SetClientNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetStatusCompleterBase::Reply(uint32_t device_status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatusResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetStatusResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetStatusResponse(
+ ::fidl::DecodedMessage<GetStatusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatusResponse::PrimarySize,
+ GetStatusResponse::PrimarySize)));
+ _response.device_status = std::move(device_status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStatusResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetStatusResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetStatusCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t device_status) {
+ if (_buffer.capacity() < GetStatusResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetStatusResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetStatusResponse(
+ ::fidl::DecodedMessage<GetStatusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatusResponse::PrimarySize,
+ GetStatusResponse::PrimarySize)));
+ _response.device_status = std::move(device_status);
+ _buffer.set_actual(sizeof(GetStatusResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetStatusResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetStatusCompleterBase::Reply(::fidl::DecodedMessage<GetStatusResponse> params) {
+ Device::SetTransactionHeaderFor::GetStatusResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetPromiscuousModeCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetPromiscuousModeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetPromiscuousModeResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetPromiscuousModeResponse(
+ ::fidl::DecodedMessage<SetPromiscuousModeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetPromiscuousModeResponse::PrimarySize,
+ SetPromiscuousModeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetPromiscuousModeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetPromiscuousModeResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetPromiscuousModeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetPromiscuousModeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetPromiscuousModeResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetPromiscuousModeResponse(
+ ::fidl::DecodedMessage<SetPromiscuousModeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetPromiscuousModeResponse::PrimarySize,
+ SetPromiscuousModeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetPromiscuousModeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetPromiscuousModeResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetPromiscuousModeCompleterBase::Reply(::fidl::DecodedMessage<SetPromiscuousModeResponse> params) {
+ Device::SetTransactionHeaderFor::SetPromiscuousModeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ConfigMulticastAddMacCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigMulticastAddMacResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConfigMulticastAddMacResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ConfigMulticastAddMacResponse(
+ ::fidl::DecodedMessage<ConfigMulticastAddMacResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigMulticastAddMacResponse::PrimarySize,
+ ConfigMulticastAddMacResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigMulticastAddMacResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigMulticastAddMacResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::ConfigMulticastAddMacCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ConfigMulticastAddMacResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConfigMulticastAddMacResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::ConfigMulticastAddMacResponse(
+ ::fidl::DecodedMessage<ConfigMulticastAddMacResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigMulticastAddMacResponse::PrimarySize,
+ ConfigMulticastAddMacResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ConfigMulticastAddMacResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigMulticastAddMacResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::ConfigMulticastAddMacCompleterBase::Reply(::fidl::DecodedMessage<ConfigMulticastAddMacResponse> params) {
+ Device::SetTransactionHeaderFor::ConfigMulticastAddMacResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ConfigMulticastDeleteMacCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigMulticastDeleteMacResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConfigMulticastDeleteMacResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ConfigMulticastDeleteMacResponse(
+ ::fidl::DecodedMessage<ConfigMulticastDeleteMacResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigMulticastDeleteMacResponse::PrimarySize,
+ ConfigMulticastDeleteMacResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigMulticastDeleteMacResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigMulticastDeleteMacResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::ConfigMulticastDeleteMacCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ConfigMulticastDeleteMacResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConfigMulticastDeleteMacResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::ConfigMulticastDeleteMacResponse(
+ ::fidl::DecodedMessage<ConfigMulticastDeleteMacResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigMulticastDeleteMacResponse::PrimarySize,
+ ConfigMulticastDeleteMacResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ConfigMulticastDeleteMacResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigMulticastDeleteMacResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::ConfigMulticastDeleteMacCompleterBase::Reply(::fidl::DecodedMessage<ConfigMulticastDeleteMacResponse> params) {
+ Device::SetTransactionHeaderFor::ConfigMulticastDeleteMacResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ConfigMulticastSetPromiscuousModeCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigMulticastSetPromiscuousModeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConfigMulticastSetPromiscuousModeResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ConfigMulticastSetPromiscuousModeResponse(
+ ::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigMulticastSetPromiscuousModeResponse::PrimarySize,
+ ConfigMulticastSetPromiscuousModeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigMulticastSetPromiscuousModeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::ConfigMulticastSetPromiscuousModeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ConfigMulticastSetPromiscuousModeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConfigMulticastSetPromiscuousModeResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::ConfigMulticastSetPromiscuousModeResponse(
+ ::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigMulticastSetPromiscuousModeResponse::PrimarySize,
+ ConfigMulticastSetPromiscuousModeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ConfigMulticastSetPromiscuousModeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::ConfigMulticastSetPromiscuousModeCompleterBase::Reply(::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeResponse> params) {
+ Device::SetTransactionHeaderFor::ConfigMulticastSetPromiscuousModeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ConfigMulticastTestFilterCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigMulticastTestFilterResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConfigMulticastTestFilterResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ConfigMulticastTestFilterResponse(
+ ::fidl::DecodedMessage<ConfigMulticastTestFilterResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigMulticastTestFilterResponse::PrimarySize,
+ ConfigMulticastTestFilterResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigMulticastTestFilterResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigMulticastTestFilterResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::ConfigMulticastTestFilterCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ConfigMulticastTestFilterResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConfigMulticastTestFilterResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::ConfigMulticastTestFilterResponse(
+ ::fidl::DecodedMessage<ConfigMulticastTestFilterResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigMulticastTestFilterResponse::PrimarySize,
+ ConfigMulticastTestFilterResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ConfigMulticastTestFilterResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigMulticastTestFilterResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::ConfigMulticastTestFilterCompleterBase::Reply(::fidl::DecodedMessage<ConfigMulticastTestFilterResponse> params) {
+ Device::SetTransactionHeaderFor::ConfigMulticastTestFilterResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::DumpRegistersCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DumpRegistersResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DumpRegistersResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::DumpRegistersResponse(
+ ::fidl::DecodedMessage<DumpRegistersResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DumpRegistersResponse::PrimarySize,
+ DumpRegistersResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DumpRegistersResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DumpRegistersResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::DumpRegistersCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < DumpRegistersResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DumpRegistersResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::DumpRegistersResponse(
+ ::fidl::DecodedMessage<DumpRegistersResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DumpRegistersResponse::PrimarySize,
+ DumpRegistersResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(DumpRegistersResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DumpRegistersResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::DumpRegistersCompleterBase::Reply(::fidl::DecodedMessage<DumpRegistersResponse> params) {
+ Device::SetTransactionHeaderFor::DumpRegistersResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<Device::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<Device::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetFifosRequest(const ::fidl::DecodedMessage<Device::GetFifosRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetFifos_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetFifosResponse(const ::fidl::DecodedMessage<Device::GetFifosResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetFifos_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetIOBufferRequest(const ::fidl::DecodedMessage<Device::SetIOBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetIOBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetIOBufferResponse(const ::fidl::DecodedMessage<Device::SetIOBufferResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetIOBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::StartRequest(const ::fidl::DecodedMessage<Device::StartRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Start_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::StartResponse(const ::fidl::DecodedMessage<Device::StartResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Start_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::StopRequest(const ::fidl::DecodedMessage<Device::StopRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Stop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::StopResponse(const ::fidl::DecodedMessage<Device::StopResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Stop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ListenStartRequest(const ::fidl::DecodedMessage<Device::ListenStartRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ListenStart_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ListenStartResponse(const ::fidl::DecodedMessage<Device::ListenStartResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ListenStart_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ListenStopRequest(const ::fidl::DecodedMessage<Device::ListenStopRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ListenStop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ListenStopResponse(const ::fidl::DecodedMessage<Device::ListenStopResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ListenStop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetClientNameRequest(const ::fidl::DecodedMessage<Device::SetClientNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetClientName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetClientNameResponse(const ::fidl::DecodedMessage<Device::SetClientNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetClientName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetStatusRequest(const ::fidl::DecodedMessage<Device::GetStatusRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStatus_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetStatusResponse(const ::fidl::DecodedMessage<Device::GetStatusResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStatus_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetPromiscuousModeRequest(const ::fidl::DecodedMessage<Device::SetPromiscuousModeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetPromiscuousMode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetPromiscuousModeResponse(const ::fidl::DecodedMessage<Device::SetPromiscuousModeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetPromiscuousMode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ConfigMulticastAddMacRequest(const ::fidl::DecodedMessage<Device::ConfigMulticastAddMacRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ConfigMulticastAddMac_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ConfigMulticastAddMacResponse(const ::fidl::DecodedMessage<Device::ConfigMulticastAddMacResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ConfigMulticastAddMac_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ConfigMulticastDeleteMacRequest(const ::fidl::DecodedMessage<Device::ConfigMulticastDeleteMacRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ConfigMulticastDeleteMac_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ConfigMulticastDeleteMacResponse(const ::fidl::DecodedMessage<Device::ConfigMulticastDeleteMacResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ConfigMulticastDeleteMac_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ConfigMulticastSetPromiscuousModeRequest(const ::fidl::DecodedMessage<Device::ConfigMulticastSetPromiscuousModeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ConfigMulticastSetPromiscuousMode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ConfigMulticastSetPromiscuousModeResponse(const ::fidl::DecodedMessage<Device::ConfigMulticastSetPromiscuousModeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ConfigMulticastSetPromiscuousMode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ConfigMulticastTestFilterRequest(const ::fidl::DecodedMessage<Device::ConfigMulticastTestFilterRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ConfigMulticastTestFilter_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ConfigMulticastTestFilterResponse(const ::fidl::DecodedMessage<Device::ConfigMulticastTestFilterResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ConfigMulticastTestFilter_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::DumpRegistersRequest(const ::fidl::DecodedMessage<Device::DumpRegistersRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_DumpRegisters_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::DumpRegistersResponse(const ::fidl::DecodedMessage<Device::DumpRegistersResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_DumpRegisters_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace ethernet
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-ethernet/gen/llcpp/include/fuchsia/hardware/ethernet/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-ethernet/gen/llcpp/include/fuchsia/hardware/ethernet/llcpp/fidl.h
new file mode 100644
index 0000000..501960c
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-ethernet/gen/llcpp/include/fuchsia/hardware/ethernet/llcpp/fidl.h
@@ -0,0 +1,1698 @@
+// 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>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace ethernet {
+
+struct MacAddress;
+struct Info;
+class Device;
+struct Fifos;
+
+constexpr uint32_t SIGNAL_STATUS = 16777216u;
+
+constexpr uint32_t SET_CLIENT_NAME_MAX_LEN = 16u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_MacAddressTable;
+
+struct MacAddress {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_MacAddressTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 6;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::fidl::Array<uint8_t, 6> octets = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_InfoTable;
+
+struct Info {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_InfoTable;
+ 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;
+
+ uint32_t features = {};
+
+ uint32_t mtu = {};
+
+ ::llcpp::fuchsia::hardware::ethernet::MacAddress mac = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetFifosRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetFifosResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetIOBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetIOBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceStartResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceStopResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceListenStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceListenStartResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceListenStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceListenStopResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetClientNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetClientNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetStatusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceGetStatusResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetPromiscuousModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceSetPromiscuousModeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastAddMacRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastAddMacResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastDeleteMacRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastDeleteMacResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousModeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastTestFilterRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceConfigMulticastTestFilterResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceDumpRegistersRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_DeviceDumpRegistersResponseTable;
+
+// Operation
+//
+// Packets are transmitted by writing data into the IO buffer and writing
+// a FifoEntry referencing that data (offset + length) into the tx fifo.
+// When the driver is done accessing the data, a FifoEntry with the same
+// cookie value (opaque to the driver) will be readable from the tx fifo.
+//
+// Packets are received by writing a FifoEntry referencing an available
+// buffer (offset + length) in the IO buffer. When a packet is received,
+// a FifoEntry with the same cookie value (opaque to the driver) will be
+// readable from the rx fifo. The offset field will be the same as was
+// sent. The length field will reflect the actual size of the received
+// packet. The flags field will indicate success or a specific failure
+// condition.
+//
+// IMPORTANT: The driver *will not* buffer response messages. It is the
+// client's responsibility to ensure that there is space in the reply side
+// of each fifo for each outstanding tx or rx request. The fifo sizes
+// are returned along with the fifo handles from GetFifos().
+//
+// See //zircon/system/public/zircon/device/ethernet.h for fifo entry layout
+// and request / response message bits.
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::ethernet::Info info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceGetInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 GetInfoRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetFifosResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::hardware::ethernet::Fifos* info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceGetFifosResponseTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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 GetFifosRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetIOBufferResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceSetIOBufferResponseTable;
+ 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 SetIOBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo h;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceSetIOBufferRequestTable;
+ 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 = SetIOBufferResponse;
+ };
+
+ struct StartResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceStartResponseTable;
+ 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 StartRequest = ::fidl::AnyZeroArgMessage;
+
+ using StopResponse = ::fidl::AnyZeroArgMessage;
+ using StopRequest = ::fidl::AnyZeroArgMessage;
+
+ struct ListenStartResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceListenStartResponseTable;
+ 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 ListenStartRequest = ::fidl::AnyZeroArgMessage;
+
+ using ListenStopResponse = ::fidl::AnyZeroArgMessage;
+ using ListenStopRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetClientNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceSetClientNameResponseTable;
+ 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 SetClientNameRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView name;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceSetClientNameRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 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::kRequest;
+ using ResponseType = SetClientNameResponse;
+ };
+
+ struct GetStatusResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t device_status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceGetStatusResponseTable;
+ 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 GetStatusRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetPromiscuousModeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceSetPromiscuousModeResponseTable;
+ 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 SetPromiscuousModeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool enabled;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceSetPromiscuousModeRequestTable;
+ 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 = SetPromiscuousModeResponse;
+ };
+
+ struct ConfigMulticastAddMacResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceConfigMulticastAddMacResponseTable;
+ 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 ConfigMulticastAddMacRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::ethernet::MacAddress addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceConfigMulticastAddMacRequestTable;
+ 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 = ConfigMulticastAddMacResponse;
+ };
+
+ struct ConfigMulticastDeleteMacResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceConfigMulticastDeleteMacResponseTable;
+ 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 ConfigMulticastDeleteMacRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::ethernet::MacAddress addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceConfigMulticastDeleteMacRequestTable;
+ 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 = ConfigMulticastDeleteMacResponse;
+ };
+
+ struct ConfigMulticastSetPromiscuousModeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousModeResponseTable;
+ 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 ConfigMulticastSetPromiscuousModeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool enabled;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceConfigMulticastSetPromiscuousModeRequestTable;
+ 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 = ConfigMulticastSetPromiscuousModeResponse;
+ };
+
+ struct ConfigMulticastTestFilterResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceConfigMulticastTestFilterResponseTable;
+ 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 ConfigMulticastTestFilterRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DumpRegistersResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_DeviceDumpRegistersResponseTable;
+ 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 DumpRegistersRequest = ::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 GetFifos_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetFifos_Impl(::zx::unowned_channel _client_end);
+ ~GetFifos_Impl() = default;
+ GetFifos_Impl(GetFifos_Impl&& other) = default;
+ GetFifos_Impl& operator=(GetFifos_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 SetIOBuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetIOBuffer_Impl(::zx::unowned_channel _client_end, ::zx::vmo h);
+ ~SetIOBuffer_Impl() = default;
+ SetIOBuffer_Impl(SetIOBuffer_Impl&& other) = default;
+ SetIOBuffer_Impl& operator=(SetIOBuffer_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 Start_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Start_Impl(::zx::unowned_channel _client_end);
+ ~Start_Impl() = default;
+ Start_Impl(Start_Impl&& other) = default;
+ Start_Impl& operator=(Start_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 Stop_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Stop_Impl(::zx::unowned_channel _client_end);
+ ~Stop_Impl() = default;
+ Stop_Impl(Stop_Impl&& other) = default;
+ Stop_Impl& operator=(Stop_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 ListenStart_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ListenStart_Impl(::zx::unowned_channel _client_end);
+ ~ListenStart_Impl() = default;
+ ListenStart_Impl(ListenStart_Impl&& other) = default;
+ ListenStart_Impl& operator=(ListenStart_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 ListenStop_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ListenStop_Impl(::zx::unowned_channel _client_end);
+ ~ListenStop_Impl() = default;
+ ListenStop_Impl(ListenStop_Impl&& other) = default;
+ ListenStop_Impl& operator=(ListenStop_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 SetClientName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetClientName_Impl(::zx::unowned_channel _client_end, ::fidl::StringView name);
+ ~SetClientName_Impl() = default;
+ SetClientName_Impl(SetClientName_Impl&& other) = default;
+ SetClientName_Impl& operator=(SetClientName_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 GetStatus_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetStatus_Impl(::zx::unowned_channel _client_end);
+ ~GetStatus_Impl() = default;
+ GetStatus_Impl(GetStatus_Impl&& other) = default;
+ GetStatus_Impl& operator=(GetStatus_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 SetPromiscuousMode_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetPromiscuousMode_Impl(::zx::unowned_channel _client_end, bool enabled);
+ ~SetPromiscuousMode_Impl() = default;
+ SetPromiscuousMode_Impl(SetPromiscuousMode_Impl&& other) = default;
+ SetPromiscuousMode_Impl& operator=(SetPromiscuousMode_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 ConfigMulticastAddMac_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ConfigMulticastAddMac_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr);
+ ~ConfigMulticastAddMac_Impl() = default;
+ ConfigMulticastAddMac_Impl(ConfigMulticastAddMac_Impl&& other) = default;
+ ConfigMulticastAddMac_Impl& operator=(ConfigMulticastAddMac_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 ConfigMulticastDeleteMac_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ConfigMulticastDeleteMac_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr);
+ ~ConfigMulticastDeleteMac_Impl() = default;
+ ConfigMulticastDeleteMac_Impl(ConfigMulticastDeleteMac_Impl&& other) = default;
+ ConfigMulticastDeleteMac_Impl& operator=(ConfigMulticastDeleteMac_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 ConfigMulticastSetPromiscuousMode_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ConfigMulticastSetPromiscuousMode_Impl(::zx::unowned_channel _client_end, bool enabled);
+ ~ConfigMulticastSetPromiscuousMode_Impl() = default;
+ ConfigMulticastSetPromiscuousMode_Impl(ConfigMulticastSetPromiscuousMode_Impl&& other) = default;
+ ConfigMulticastSetPromiscuousMode_Impl& operator=(ConfigMulticastSetPromiscuousMode_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 ConfigMulticastTestFilter_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ConfigMulticastTestFilter_Impl(::zx::unowned_channel _client_end);
+ ~ConfigMulticastTestFilter_Impl() = default;
+ ConfigMulticastTestFilter_Impl(ConfigMulticastTestFilter_Impl&& other) = default;
+ ConfigMulticastTestFilter_Impl& operator=(ConfigMulticastTestFilter_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 DumpRegisters_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ DumpRegisters_Impl(::zx::unowned_channel _client_end);
+ ~DumpRegisters_Impl() = default;
+ DumpRegisters_Impl(DumpRegisters_Impl&& other) = default;
+ DumpRegisters_Impl& operator=(DumpRegisters_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 GetFifos = GetFifos_Impl<GetFifosResponse>;
+ using SetIOBuffer = SetIOBuffer_Impl<SetIOBufferResponse>;
+ using Start = Start_Impl<StartResponse>;
+ using Stop = Stop_Impl<StopResponse>;
+ using ListenStart = ListenStart_Impl<ListenStartResponse>;
+ using ListenStop = ListenStop_Impl<ListenStopResponse>;
+ using SetClientName = SetClientName_Impl<SetClientNameResponse>;
+ using GetStatus = GetStatus_Impl<GetStatusResponse>;
+ using SetPromiscuousMode = SetPromiscuousMode_Impl<SetPromiscuousModeResponse>;
+ using ConfigMulticastAddMac = ConfigMulticastAddMac_Impl<ConfigMulticastAddMacResponse>;
+ using ConfigMulticastDeleteMac = ConfigMulticastDeleteMac_Impl<ConfigMulticastDeleteMacResponse>;
+ using ConfigMulticastSetPromiscuousMode = ConfigMulticastSetPromiscuousMode_Impl<ConfigMulticastSetPromiscuousModeResponse>;
+ using ConfigMulticastTestFilter = ConfigMulticastTestFilter_Impl<ConfigMulticastTestFilterResponse>;
+ using DumpRegisters = DumpRegisters_Impl<DumpRegistersResponse>;
+ };
+
+ // 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 GetFifos_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetFifos_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetFifos_Impl() = default;
+ GetFifos_Impl(GetFifos_Impl&& other) = default;
+ GetFifos_Impl& operator=(GetFifos_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 SetIOBuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetIOBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo h, ::fidl::BytePart _response_buffer);
+ ~SetIOBuffer_Impl() = default;
+ SetIOBuffer_Impl(SetIOBuffer_Impl&& other) = default;
+ SetIOBuffer_Impl& operator=(SetIOBuffer_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 Start_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Start_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Start_Impl() = default;
+ Start_Impl(Start_Impl&& other) = default;
+ Start_Impl& operator=(Start_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 Stop_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Stop_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Stop_Impl() = default;
+ Stop_Impl(Stop_Impl&& other) = default;
+ Stop_Impl& operator=(Stop_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 ListenStart_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ListenStart_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ListenStart_Impl() = default;
+ ListenStart_Impl(ListenStart_Impl&& other) = default;
+ ListenStart_Impl& operator=(ListenStart_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 ListenStop_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ListenStop_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ListenStop_Impl() = default;
+ ListenStop_Impl(ListenStop_Impl&& other) = default;
+ ListenStop_Impl& operator=(ListenStop_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 SetClientName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetClientName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer);
+ ~SetClientName_Impl() = default;
+ SetClientName_Impl(SetClientName_Impl&& other) = default;
+ SetClientName_Impl& operator=(SetClientName_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 GetStatus_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetStatus_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetStatus_Impl() = default;
+ GetStatus_Impl(GetStatus_Impl&& other) = default;
+ GetStatus_Impl& operator=(GetStatus_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 SetPromiscuousMode_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetPromiscuousMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer);
+ ~SetPromiscuousMode_Impl() = default;
+ SetPromiscuousMode_Impl(SetPromiscuousMode_Impl&& other) = default;
+ SetPromiscuousMode_Impl& operator=(SetPromiscuousMode_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 ConfigMulticastAddMac_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ConfigMulticastAddMac_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer);
+ ~ConfigMulticastAddMac_Impl() = default;
+ ConfigMulticastAddMac_Impl(ConfigMulticastAddMac_Impl&& other) = default;
+ ConfigMulticastAddMac_Impl& operator=(ConfigMulticastAddMac_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 ConfigMulticastDeleteMac_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ConfigMulticastDeleteMac_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer);
+ ~ConfigMulticastDeleteMac_Impl() = default;
+ ConfigMulticastDeleteMac_Impl(ConfigMulticastDeleteMac_Impl&& other) = default;
+ ConfigMulticastDeleteMac_Impl& operator=(ConfigMulticastDeleteMac_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 ConfigMulticastSetPromiscuousMode_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ConfigMulticastSetPromiscuousMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer);
+ ~ConfigMulticastSetPromiscuousMode_Impl() = default;
+ ConfigMulticastSetPromiscuousMode_Impl(ConfigMulticastSetPromiscuousMode_Impl&& other) = default;
+ ConfigMulticastSetPromiscuousMode_Impl& operator=(ConfigMulticastSetPromiscuousMode_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 ConfigMulticastTestFilter_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ConfigMulticastTestFilter_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ConfigMulticastTestFilter_Impl() = default;
+ ConfigMulticastTestFilter_Impl(ConfigMulticastTestFilter_Impl&& other) = default;
+ ConfigMulticastTestFilter_Impl& operator=(ConfigMulticastTestFilter_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 DumpRegisters_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ DumpRegisters_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~DumpRegisters_Impl() = default;
+ DumpRegisters_Impl(DumpRegisters_Impl&& other) = default;
+ DumpRegisters_Impl& operator=(DumpRegisters_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 GetFifos = GetFifos_Impl<GetFifosResponse>;
+ using SetIOBuffer = SetIOBuffer_Impl<SetIOBufferResponse>;
+ using Start = Start_Impl<StartResponse>;
+ using Stop = Stop_Impl<StopResponse>;
+ using ListenStart = ListenStart_Impl<ListenStartResponse>;
+ using ListenStop = ListenStop_Impl<ListenStopResponse>;
+ using SetClientName = SetClientName_Impl<SetClientNameResponse>;
+ using GetStatus = GetStatus_Impl<GetStatusResponse>;
+ using SetPromiscuousMode = SetPromiscuousMode_Impl<SetPromiscuousModeResponse>;
+ using ConfigMulticastAddMac = ConfigMulticastAddMac_Impl<ConfigMulticastAddMacResponse>;
+ using ConfigMulticastDeleteMac = ConfigMulticastDeleteMac_Impl<ConfigMulticastDeleteMacResponse>;
+ using ConfigMulticastSetPromiscuousMode = ConfigMulticastSetPromiscuousMode_Impl<ConfigMulticastSetPromiscuousModeResponse>;
+ using ConfigMulticastTestFilter = ConfigMulticastTestFilter_Impl<ConfigMulticastTestFilterResponse>;
+ using DumpRegisters = DumpRegisters_Impl<DumpRegistersResponse>;
+ };
+
+ 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 48 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 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetFifos GetFifos();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetFifos GetFifos(::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetIOBuffer SetIOBuffer(::zx::vmo h);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetIOBuffer SetIOBuffer(::fidl::BytePart _request_buffer, ::zx::vmo h, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Start Start();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Start Start(::fidl::BytePart _response_buffer);
+
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Stop Stop();
+
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ListenStart ListenStart();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ListenStart ListenStart(::fidl::BytePart _response_buffer);
+
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ListenStop ListenStop();
+
+
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetClientName SetClientName(::fidl::StringView name);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetClientName SetClientName(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetStatus GetStatus();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetStatus GetStatus(::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetPromiscuousMode SetPromiscuousMode(bool enabled);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetPromiscuousMode SetPromiscuousMode(::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConfigMulticastAddMac ConfigMulticastAddMac(::llcpp::fuchsia::hardware::ethernet::MacAddress addr);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConfigMulticastAddMac ConfigMulticastAddMac(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConfigMulticastDeleteMac ConfigMulticastDeleteMac(::llcpp::fuchsia::hardware::ethernet::MacAddress addr);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConfigMulticastDeleteMac ConfigMulticastDeleteMac(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConfigMulticastSetPromiscuousMode ConfigMulticastSetPromiscuousMode(bool enabled);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConfigMulticastSetPromiscuousMode ConfigMulticastSetPromiscuousMode(::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConfigMulticastTestFilter ConfigMulticastTestFilter();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConfigMulticastTestFilter ConfigMulticastTestFilter(::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DumpRegisters DumpRegisters();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DumpRegisters DumpRegisters(::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 48 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 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetFifos GetFifos(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetFifos GetFifos(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetIOBuffer SetIOBuffer(::zx::unowned_channel _client_end, ::zx::vmo h);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetIOBuffer SetIOBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo h, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Start Start(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Start Start(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Stop Stop(::zx::unowned_channel _client_end);
+
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ListenStart ListenStart(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ListenStart ListenStart(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ListenStop ListenStop(::zx::unowned_channel _client_end);
+
+
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetClientName SetClientName(::zx::unowned_channel _client_end, ::fidl::StringView name);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetClientName SetClientName(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetStatus GetStatus(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetStatus GetStatus(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetPromiscuousMode SetPromiscuousMode(::zx::unowned_channel _client_end, bool enabled);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetPromiscuousMode SetPromiscuousMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConfigMulticastAddMac ConfigMulticastAddMac(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConfigMulticastAddMac ConfigMulticastAddMac(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConfigMulticastDeleteMac ConfigMulticastDeleteMac(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConfigMulticastDeleteMac ConfigMulticastDeleteMac(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConfigMulticastSetPromiscuousMode ConfigMulticastSetPromiscuousMode(::zx::unowned_channel _client_end, bool enabled);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConfigMulticastSetPromiscuousMode ConfigMulticastSetPromiscuousMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConfigMulticastTestFilter ConfigMulticastTestFilter(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConfigMulticastTestFilter ConfigMulticastTestFilter(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DumpRegisters DumpRegisters(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DumpRegisters DumpRegisters(::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<GetFifosResponse> GetFifos(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<SetIOBufferResponse> SetIOBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetIOBufferRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<StartResponse> Start(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<StopResponse> Stop(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ListenStartResponse> ListenStart(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ListenStopResponse> ListenStop(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<SetClientNameResponse> SetClientName(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetClientNameRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetStatusResponse> GetStatus(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<SetPromiscuousModeResponse> SetPromiscuousMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPromiscuousModeRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ConfigMulticastAddMacResponse> ConfigMulticastAddMac(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigMulticastAddMacRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ConfigMulticastDeleteMacResponse> ConfigMulticastDeleteMac(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigMulticastDeleteMacRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ConfigMulticastSetPromiscuousModeResponse> ConfigMulticastSetPromiscuousMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ConfigMulticastTestFilterResponse> ConfigMulticastTestFilter(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<DumpRegistersResponse> DumpRegisters(::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 = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetInfoCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::ethernet::Info info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::ethernet::Info 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 GetFifosCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::hardware::ethernet::Fifos* info);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::ethernet::Fifos* info);
+ void Reply(::fidl::DecodedMessage<GetFifosResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetFifosCompleter = ::fidl::Completer<GetFifosCompleterBase>;
+
+ virtual void GetFifos(GetFifosCompleter::Sync _completer) = 0;
+
+ class SetIOBufferCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetIOBufferResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetIOBufferCompleter = ::fidl::Completer<SetIOBufferCompleterBase>;
+
+ virtual void SetIOBuffer(::zx::vmo h, SetIOBufferCompleter::Sync _completer) = 0;
+
+ class StartCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<StartResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StartCompleter = ::fidl::Completer<StartCompleterBase>;
+
+ virtual void Start(StartCompleter::Sync _completer) = 0;
+
+ class StopCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StopCompleter = ::fidl::Completer<StopCompleterBase>;
+
+ virtual void Stop(StopCompleter::Sync _completer) = 0;
+
+ class ListenStartCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ListenStartResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ListenStartCompleter = ::fidl::Completer<ListenStartCompleterBase>;
+
+ virtual void ListenStart(ListenStartCompleter::Sync _completer) = 0;
+
+ class ListenStopCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ListenStopCompleter = ::fidl::Completer<ListenStopCompleterBase>;
+
+ virtual void ListenStop(ListenStopCompleter::Sync _completer) = 0;
+
+ class SetClientNameCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetClientNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetClientNameCompleter = ::fidl::Completer<SetClientNameCompleterBase>;
+
+ virtual void SetClientName(::fidl::StringView name, SetClientNameCompleter::Sync _completer) = 0;
+
+ class GetStatusCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t device_status);
+ void Reply(::fidl::BytePart _buffer, uint32_t device_status);
+ void Reply(::fidl::DecodedMessage<GetStatusResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetStatusCompleter = ::fidl::Completer<GetStatusCompleterBase>;
+
+ virtual void GetStatus(GetStatusCompleter::Sync _completer) = 0;
+
+ class SetPromiscuousModeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetPromiscuousModeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetPromiscuousModeCompleter = ::fidl::Completer<SetPromiscuousModeCompleterBase>;
+
+ virtual void SetPromiscuousMode(bool enabled, SetPromiscuousModeCompleter::Sync _completer) = 0;
+
+ class ConfigMulticastAddMacCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ConfigMulticastAddMacResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConfigMulticastAddMacCompleter = ::fidl::Completer<ConfigMulticastAddMacCompleterBase>;
+
+ virtual void ConfigMulticastAddMac(::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ConfigMulticastAddMacCompleter::Sync _completer) = 0;
+
+ class ConfigMulticastDeleteMacCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ConfigMulticastDeleteMacResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConfigMulticastDeleteMacCompleter = ::fidl::Completer<ConfigMulticastDeleteMacCompleterBase>;
+
+ virtual void ConfigMulticastDeleteMac(::llcpp::fuchsia::hardware::ethernet::MacAddress addr, ConfigMulticastDeleteMacCompleter::Sync _completer) = 0;
+
+ class ConfigMulticastSetPromiscuousModeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ConfigMulticastSetPromiscuousModeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConfigMulticastSetPromiscuousModeCompleter = ::fidl::Completer<ConfigMulticastSetPromiscuousModeCompleterBase>;
+
+ virtual void ConfigMulticastSetPromiscuousMode(bool enabled, ConfigMulticastSetPromiscuousModeCompleter::Sync _completer) = 0;
+
+ class ConfigMulticastTestFilterCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ConfigMulticastTestFilterResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConfigMulticastTestFilterCompleter = ::fidl::Completer<ConfigMulticastTestFilterCompleterBase>;
+
+ virtual void ConfigMulticastTestFilter(ConfigMulticastTestFilterCompleter::Sync _completer) = 0;
+
+ class DumpRegistersCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<DumpRegistersResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DumpRegistersCompleter = ::fidl::Completer<DumpRegistersCompleterBase>;
+
+ virtual void DumpRegisters(DumpRegistersCompleter::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<Device::GetInfoRequest>& _msg);
+ static void GetInfoResponse(const ::fidl::DecodedMessage<Device::GetInfoResponse>& _msg);
+ static void GetFifosRequest(const ::fidl::DecodedMessage<Device::GetFifosRequest>& _msg);
+ static void GetFifosResponse(const ::fidl::DecodedMessage<Device::GetFifosResponse>& _msg);
+ static void SetIOBufferRequest(const ::fidl::DecodedMessage<Device::SetIOBufferRequest>& _msg);
+ static void SetIOBufferResponse(const ::fidl::DecodedMessage<Device::SetIOBufferResponse>& _msg);
+ static void StartRequest(const ::fidl::DecodedMessage<Device::StartRequest>& _msg);
+ static void StartResponse(const ::fidl::DecodedMessage<Device::StartResponse>& _msg);
+ static void StopRequest(const ::fidl::DecodedMessage<Device::StopRequest>& _msg);
+ static void StopResponse(const ::fidl::DecodedMessage<Device::StopResponse>& _msg);
+ static void ListenStartRequest(const ::fidl::DecodedMessage<Device::ListenStartRequest>& _msg);
+ static void ListenStartResponse(const ::fidl::DecodedMessage<Device::ListenStartResponse>& _msg);
+ static void ListenStopRequest(const ::fidl::DecodedMessage<Device::ListenStopRequest>& _msg);
+ static void ListenStopResponse(const ::fidl::DecodedMessage<Device::ListenStopResponse>& _msg);
+ static void SetClientNameRequest(const ::fidl::DecodedMessage<Device::SetClientNameRequest>& _msg);
+ static void SetClientNameResponse(const ::fidl::DecodedMessage<Device::SetClientNameResponse>& _msg);
+ static void GetStatusRequest(const ::fidl::DecodedMessage<Device::GetStatusRequest>& _msg);
+ static void GetStatusResponse(const ::fidl::DecodedMessage<Device::GetStatusResponse>& _msg);
+ static void SetPromiscuousModeRequest(const ::fidl::DecodedMessage<Device::SetPromiscuousModeRequest>& _msg);
+ static void SetPromiscuousModeResponse(const ::fidl::DecodedMessage<Device::SetPromiscuousModeResponse>& _msg);
+ static void ConfigMulticastAddMacRequest(const ::fidl::DecodedMessage<Device::ConfigMulticastAddMacRequest>& _msg);
+ static void ConfigMulticastAddMacResponse(const ::fidl::DecodedMessage<Device::ConfigMulticastAddMacResponse>& _msg);
+ static void ConfigMulticastDeleteMacRequest(const ::fidl::DecodedMessage<Device::ConfigMulticastDeleteMacRequest>& _msg);
+ static void ConfigMulticastDeleteMacResponse(const ::fidl::DecodedMessage<Device::ConfigMulticastDeleteMacResponse>& _msg);
+ static void ConfigMulticastSetPromiscuousModeRequest(const ::fidl::DecodedMessage<Device::ConfigMulticastSetPromiscuousModeRequest>& _msg);
+ static void ConfigMulticastSetPromiscuousModeResponse(const ::fidl::DecodedMessage<Device::ConfigMulticastSetPromiscuousModeResponse>& _msg);
+ static void ConfigMulticastTestFilterRequest(const ::fidl::DecodedMessage<Device::ConfigMulticastTestFilterRequest>& _msg);
+ static void ConfigMulticastTestFilterResponse(const ::fidl::DecodedMessage<Device::ConfigMulticastTestFilterResponse>& _msg);
+ static void DumpRegistersRequest(const ::fidl::DecodedMessage<Device::DumpRegistersRequest>& _msg);
+ static void DumpRegistersResponse(const ::fidl::DecodedMessage<Device::DumpRegistersResponse>& _msg);
+ };
+};
+
+constexpr uint32_t MAX_CLIENT_NAME_LEN = 15u;
+
+constexpr uint32_t INFO_FEATURE_WLAN = 1u;
+
+constexpr uint32_t INFO_FEATURE_SYNTH = 2u;
+
+constexpr uint32_t INFO_FEATURE_LOOPBACK = 4u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_ethernet_FifosTable;
+
+struct Fifos {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ethernet_FifosTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::fifo rx = {};
+
+ ::zx::fifo tx = {};
+
+ uint32_t rx_depth = {};
+
+ uint32_t tx_depth = {};
+};
+
+constexpr uint32_t DEVICE_STATUS_ONLINE = 1u;
+
+} // namespace ethernet
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::MacAddress> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::ethernet::MacAddress>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::MacAddress, octets) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::MacAddress) == ::llcpp::fuchsia::hardware::ethernet::MacAddress::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Info> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::ethernet::Info>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Info, features) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Info, mtu) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Info, mac) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Info) == ::llcpp::fuchsia::hardware::ethernet::Info::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::GetInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::GetInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::GetInfoResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::GetInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::GetInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::GetFifosResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::GetFifosResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::GetFifosResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::GetFifosResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::GetFifosResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::GetFifosResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferRequest)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferRequest, h) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::SetIOBufferResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::StartResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::StartResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::StartResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::StartResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::StartResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::ListenStartResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::ListenStartResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::ListenStartResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::ListenStartResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::ListenStartResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameRequest)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameRequest, name) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::SetClientNameResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::GetStatusResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::GetStatusResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::GetStatusResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::GetStatusResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::GetStatusResponse, device_status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeRequest)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeRequest, enabled) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::SetPromiscuousModeResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacRequest)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastAddMacResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacRequest)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastDeleteMacResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeRequest)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeRequest, enabled) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastSetPromiscuousModeResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastTestFilterResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastTestFilterResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastTestFilterResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastTestFilterResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::ConfigMulticastTestFilterResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Device::DumpRegistersResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ethernet::Device::DumpRegistersResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Device::DumpRegistersResponse)
+ == ::llcpp::fuchsia::hardware::ethernet::Device::DumpRegistersResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Device::DumpRegistersResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ethernet::Fifos> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::ethernet::Fifos>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Fifos, rx) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Fifos, tx) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Fifos, rx_depth) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ethernet::Fifos, tx_depth) == 12);
+static_assert(sizeof(::llcpp::fuchsia::hardware::ethernet::Fifos) == ::llcpp::fuchsia::hardware::ethernet::Fifos::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-ftdi/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-ftdi/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..296f6ae
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-ftdi/gen/llcpp/fidl.cc
@@ -0,0 +1,139 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/ftdi/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace ftdi {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_CreateI2C_Ordinal = 0x6e215cdf00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_CreateI2C_GenOrdinal = 0x1d8122e93efc5fdblu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ftdi_DeviceCreateI2CRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ftdi_DeviceCreateI2CResponseTable;
+
+} // namespace
+
+Device::ResultOf::CreateI2C_Impl::CreateI2C_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateI2CRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CreateI2CRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateI2CRequest*>(_write_bytes);
+ _request.layout = std::move(layout);
+ _request.device = std::move(device);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateI2CRequest));
+ ::fidl::DecodedMessage<CreateI2CRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Device::InPlace::CreateI2C(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::ResultOf::CreateI2C Device::SyncClient::CreateI2C(::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device) {
+ return ResultOf::CreateI2C(::zx::unowned_channel(this->channel_), std::move(layout), std::move(device));
+}
+
+Device::ResultOf::CreateI2C Device::Call::CreateI2C(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device) {
+ return ResultOf::CreateI2C(std::move(_client_end), std::move(layout), std::move(device));
+}
+
+
+Device::UnownedResultOf::CreateI2C_Impl::CreateI2C_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device) {
+ if (_request_buffer.capacity() < CreateI2CRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CreateI2CRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateI2CRequest*>(_request_buffer.data());
+ _request.layout = std::move(layout);
+ _request.device = std::move(device);
+ _request_buffer.set_actual(sizeof(CreateI2CRequest));
+ ::fidl::DecodedMessage<CreateI2CRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Device::InPlace::CreateI2C(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::UnownedResultOf::CreateI2C Device::SyncClient::CreateI2C(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device) {
+ return UnownedResultOf::CreateI2C(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(layout), std::move(device));
+}
+
+Device::UnownedResultOf::CreateI2C Device::Call::CreateI2C(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device) {
+ return UnownedResultOf::CreateI2C(std::move(_client_end), std::move(_request_buffer), std::move(layout), std::move(device));
+}
+
+::fidl::internal::StatusAndError Device::InPlace::CreateI2C(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateI2CRequest> params) {
+ Device::SetTransactionHeaderFor::CreateI2CRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_CreateI2C_Ordinal:
+ case kDevice_CreateI2C_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateI2CRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateI2C(std::move(message->layout), std::move(message->device),
+ Interface::CreateI2CCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void Device::SetTransactionHeaderFor::CreateI2CRequest(const ::fidl::DecodedMessage<Device::CreateI2CRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_CreateI2C_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace ftdi
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-ftdi/gen/llcpp/include/fuchsia/hardware/ftdi/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-ftdi/gen/llcpp/include/fuchsia/hardware/ftdi/llcpp/fidl.h
new file mode 100644
index 0000000..bd9ab77
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-ftdi/gen/llcpp/include/fuchsia/hardware/ftdi/llcpp/fidl.h
@@ -0,0 +1,270 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace ftdi {
+
+struct I2cDevice;
+struct I2cBusLayout;
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_ftdi_I2cDeviceTable;
+
+// Each one of these represents an I2cDevice that will exist
+// on the newly created bus. The I2C bus will try and bind
+// a driver on the bus with the given VID, PID, DID.
+struct I2cDevice {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ftdi_I2cDeviceTable;
+ 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;
+
+ uint32_t address = {};
+
+ uint32_t vid = {};
+
+ uint32_t pid = {};
+
+ uint32_t did = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_ftdi_I2cBusLayoutTable;
+
+// This represents the data necessary for the FTDI device
+// to create an I2C bus.
+struct I2cBusLayout {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ftdi_I2cBusLayoutTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 12;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t scl = {};
+
+ // The FTDI needs two pins to be able to drive input and output for
+ // SDA. Please specify the two pins here. They *must* be physically
+ // tied together on the board with a jumper wire.
+ uint32_t sda_out = {};
+
+ uint32_t sda_in = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_ftdi_DeviceCreateI2CRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_ftdi_DeviceCreateI2CResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct CreateI2CRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout;
+ ::llcpp::fuchsia::hardware::ftdi::I2cDevice device;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_ftdi_DeviceCreateI2CRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class CreateI2C_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CreateI2C_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device);
+ ~CreateI2C_Impl() = default;
+ CreateI2C_Impl(CreateI2C_Impl&& other) = default;
+ CreateI2C_Impl& operator=(CreateI2C_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using CreateI2C = CreateI2C_Impl;
+ };
+
+ // 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:
+ class CreateI2C_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CreateI2C_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device);
+ ~CreateI2C_Impl() = default;
+ CreateI2C_Impl(CreateI2C_Impl&& other) = default;
+ CreateI2C_Impl& operator=(CreateI2C_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using CreateI2C = CreateI2C_Impl;
+ };
+
+ 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_; }
+
+ // Create an I2c bus on the FTDI device with a given `layout` and
+ // with `device` attached to it.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateI2C CreateI2C(::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device);
+
+ // Create an I2c bus on the FTDI device with a given `layout` and
+ // with `device` attached to it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateI2C CreateI2C(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device);
+
+ 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:
+
+ // Create an I2c bus on the FTDI device with a given `layout` and
+ // with `device` attached to it.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateI2C CreateI2C(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device);
+
+ // Create an I2c bus on the FTDI device with a given `layout` and
+ // with `device` attached to it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateI2C CreateI2C(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device);
+
+ };
+
+ // 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:
+
+ // Create an I2c bus on the FTDI device with a given `layout` and
+ // with `device` attached to it.
+ static ::fidl::internal::StatusAndError CreateI2C(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateI2CRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ using CreateI2CCompleter = ::fidl::Completer<>;
+
+ virtual void CreateI2C(::llcpp::fuchsia::hardware::ftdi::I2cBusLayout layout, ::llcpp::fuchsia::hardware::ftdi::I2cDevice device, CreateI2CCompleter::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 CreateI2CRequest(const ::fidl::DecodedMessage<Device::CreateI2CRequest>& _msg);
+ };
+};
+
+} // namespace ftdi
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ftdi::I2cDevice> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::ftdi::I2cDevice>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::I2cDevice, address) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::I2cDevice, vid) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::I2cDevice, pid) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::I2cDevice, did) == 12);
+static_assert(sizeof(::llcpp::fuchsia::hardware::ftdi::I2cDevice) == ::llcpp::fuchsia::hardware::ftdi::I2cDevice::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ftdi::I2cBusLayout> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::ftdi::I2cBusLayout>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::I2cBusLayout, scl) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::I2cBusLayout, sda_out) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::I2cBusLayout, sda_in) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::ftdi::I2cBusLayout) == ::llcpp::fuchsia::hardware::ftdi::I2cBusLayout::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::ftdi::Device::CreateI2CRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::ftdi::Device::CreateI2CRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::ftdi::Device::CreateI2CRequest)
+ == ::llcpp::fuchsia::hardware::ftdi::Device::CreateI2CRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::Device::CreateI2CRequest, layout) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::ftdi::Device::CreateI2CRequest, device) == 28);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-input/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-input/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..68f632e
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-input/gen/llcpp/fidl.cc
@@ -0,0 +1,1691 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/input/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace input {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetBootProtocol_Ordinal = 0x47ac8ff500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetBootProtocol_GenOrdinal = 0x54f14ad662c6899flu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetBootProtocolRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetBootProtocolResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceIds_Ordinal = 0x2213b60500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceIds_GenOrdinal = 0x3b2d696caef3c3e0lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetDeviceIdsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetDeviceIdsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportDescSize_Ordinal = 0x312dbbe100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportDescSize_GenOrdinal = 0x2fba99f2b2c6cd2flu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescSizeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportDesc_Ordinal = 0x6ae0c2f200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportDesc_GenOrdinal = 0x7fe4aff57d9019f8lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetNumReports_Ordinal = 0x79b0ee200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetNumReports_GenOrdinal = 0x57de20184ed5ba42lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetNumReportsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetNumReportsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportIds_Ordinal = 0x74f7d94f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportIds_GenOrdinal = 0x620319ad9bb99853lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportIdsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportIdsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportSize_Ordinal = 0x22e76cac00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportSize_GenOrdinal = 0x436d9de68d4e8b14lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportSizeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetMaxInputReportSize_Ordinal = 0x4e9ab77400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetMaxInputReportSize_GenOrdinal = 0x1c794da7454e1b4elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReports_Ordinal = 0x172821a100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReports_GenOrdinal = 0x620f664991c7c95dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportsEvent_Ordinal = 0x6682043100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReportsEvent_GenOrdinal = 0x6198970f9308041clu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReport_Ordinal = 0x2a267cd000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetReport_GenOrdinal = 0x5b2a44555defd970lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetReport_Ordinal = 0x14ff63cb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetReport_GenOrdinal = 0x51cc85eb4e769eelu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetReportRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetReportResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetTraceId_Ordinal = 0x67de25bb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetTraceId_GenOrdinal = 0x7fe8815219c66700lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetTraceIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetTraceIdResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetBootProtocol_Impl<Device::GetBootProtocolResponse>::GetBootProtocol_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBootProtocolRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetBootProtocolRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBootProtocolRequest));
+ ::fidl::DecodedMessage<GetBootProtocolRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetBootProtocol(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetBootProtocol Device::SyncClient::GetBootProtocol() {
+ return ResultOf::GetBootProtocol(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetBootProtocol Device::Call::GetBootProtocol(::zx::unowned_channel _client_end) {
+ return ResultOf::GetBootProtocol(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetBootProtocol_Impl<Device::GetBootProtocolResponse>::GetBootProtocol_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetBootProtocolRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetBootProtocolRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetBootProtocolRequest));
+ ::fidl::DecodedMessage<GetBootProtocolRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetBootProtocol(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetBootProtocol Device::SyncClient::GetBootProtocol(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBootProtocol(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetBootProtocol Device::Call::GetBootProtocol(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBootProtocol(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetBootProtocolResponse> Device::InPlace::GetBootProtocol(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetBootProtocolRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetBootProtocolRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetBootProtocolRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetBootProtocolResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetBootProtocolRequest, GetBootProtocolResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetBootProtocolResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetDeviceIds_Impl<Device::GetDeviceIdsResponse>::GetDeviceIds_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceIdsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDeviceIdsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceIdsRequest));
+ ::fidl::DecodedMessage<GetDeviceIdsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetDeviceIds(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetDeviceIds Device::SyncClient::GetDeviceIds() {
+ return ResultOf::GetDeviceIds(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetDeviceIds Device::Call::GetDeviceIds(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDeviceIds(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetDeviceIds_Impl<Device::GetDeviceIdsResponse>::GetDeviceIds_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceIdsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDeviceIdsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDeviceIdsRequest));
+ ::fidl::DecodedMessage<GetDeviceIdsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetDeviceIds(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetDeviceIds Device::SyncClient::GetDeviceIds(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceIds(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetDeviceIds Device::Call::GetDeviceIds(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceIds(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetDeviceIdsResponse> Device::InPlace::GetDeviceIds(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDeviceIdsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDeviceIdsRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetDeviceIdsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceIdsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDeviceIdsRequest, GetDeviceIdsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceIdsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetReportDescSize_Impl<Device::GetReportDescSizeResponse>::GetReportDescSize_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportDescSizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportDescSizeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportDescSizeRequest));
+ ::fidl::DecodedMessage<GetReportDescSizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetReportDescSize(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetReportDescSize Device::SyncClient::GetReportDescSize() {
+ return ResultOf::GetReportDescSize(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetReportDescSize Device::Call::GetReportDescSize(::zx::unowned_channel _client_end) {
+ return ResultOf::GetReportDescSize(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetReportDescSize_Impl<Device::GetReportDescSizeResponse>::GetReportDescSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetReportDescSizeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetReportDescSizeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetReportDescSizeRequest));
+ ::fidl::DecodedMessage<GetReportDescSizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetReportDescSize(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetReportDescSize Device::SyncClient::GetReportDescSize(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportDescSize(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetReportDescSize Device::Call::GetReportDescSize(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportDescSize(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetReportDescSizeResponse> Device::InPlace::GetReportDescSize(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetReportDescSizeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetReportDescSizeRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetReportDescSizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportDescSizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportDescSizeRequest, GetReportDescSizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportDescSizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetReportDesc_Impl<Device::GetReportDescResponse>::GetReportDesc_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportDescRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportDescRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportDescRequest));
+ ::fidl::DecodedMessage<GetReportDescRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetReportDesc(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetReportDesc Device::SyncClient::GetReportDesc() {
+ return ResultOf::GetReportDesc(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetReportDesc Device::Call::GetReportDesc(::zx::unowned_channel _client_end) {
+ return ResultOf::GetReportDesc(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetReportDesc_Impl<Device::GetReportDescResponse>::GetReportDesc_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetReportDescRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetReportDescRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetReportDescRequest));
+ ::fidl::DecodedMessage<GetReportDescRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetReportDesc(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetReportDesc Device::SyncClient::GetReportDesc(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportDesc(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetReportDesc Device::Call::GetReportDesc(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportDesc(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetReportDescResponse> Device::InPlace::GetReportDesc(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetReportDescRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetReportDescRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetReportDescRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportDescResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportDescRequest, GetReportDescResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportDescResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetNumReports_Impl<Device::GetNumReportsResponse>::GetNumReports_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNumReportsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNumReportsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNumReportsRequest));
+ ::fidl::DecodedMessage<GetNumReportsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetNumReports(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetNumReports Device::SyncClient::GetNumReports() {
+ return ResultOf::GetNumReports(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetNumReports Device::Call::GetNumReports(::zx::unowned_channel _client_end) {
+ return ResultOf::GetNumReports(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetNumReports_Impl<Device::GetNumReportsResponse>::GetNumReports_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNumReportsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetNumReportsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetNumReportsRequest));
+ ::fidl::DecodedMessage<GetNumReportsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetNumReports(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetNumReports Device::SyncClient::GetNumReports(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNumReports(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetNumReports Device::Call::GetNumReports(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNumReports(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetNumReportsResponse> Device::InPlace::GetNumReports(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetNumReportsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetNumReportsRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetNumReportsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetNumReportsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNumReportsRequest, GetNumReportsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetNumReportsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetReportIds_Impl<Device::GetReportIdsResponse>::GetReportIds_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportIdsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportIdsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportIdsRequest));
+ ::fidl::DecodedMessage<GetReportIdsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetReportIds(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetReportIds Device::SyncClient::GetReportIds() {
+ return ResultOf::GetReportIds(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetReportIds Device::Call::GetReportIds(::zx::unowned_channel _client_end) {
+ return ResultOf::GetReportIds(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetReportIds_Impl<Device::GetReportIdsResponse>::GetReportIds_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetReportIdsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetReportIdsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetReportIdsRequest));
+ ::fidl::DecodedMessage<GetReportIdsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetReportIds(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetReportIds Device::SyncClient::GetReportIds(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportIds(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetReportIds Device::Call::GetReportIds(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportIds(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetReportIdsResponse> Device::InPlace::GetReportIds(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetReportIdsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetReportIdsRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetReportIdsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportIdsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportIdsRequest, GetReportIdsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportIdsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetReportSize_Impl<Device::GetReportSizeResponse>::GetReportSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportSizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetReportSizeRequest*>(_write_bytes);
+ _request.type = std::move(type);
+ _request.id = std::move(id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportSizeRequest));
+ ::fidl::DecodedMessage<GetReportSizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetReportSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetReportSize Device::SyncClient::GetReportSize(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
+ return ResultOf::GetReportSize(::zx::unowned_channel(this->channel_), std::move(type), std::move(id));
+}
+
+Device::ResultOf::GetReportSize Device::Call::GetReportSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
+ return ResultOf::GetReportSize(std::move(_client_end), std::move(type), std::move(id));
+}
+
+template <>
+Device::UnownedResultOf::GetReportSize_Impl<Device::GetReportSizeResponse>::GetReportSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetReportSizeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetReportSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetReportSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetReportSizeRequest*>(_request_buffer.data());
+ _request.type = std::move(type);
+ _request.id = std::move(id);
+ _request_buffer.set_actual(sizeof(GetReportSizeRequest));
+ ::fidl::DecodedMessage<GetReportSizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetReportSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetReportSize Device::SyncClient::GetReportSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportSize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(id), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetReportSize Device::Call::GetReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportSize(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetReportSizeResponse> Device::InPlace::GetReportSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetReportSizeRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetReportSizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportSizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportSizeRequest, GetReportSizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportSizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetMaxInputReportSize_Impl<Device::GetMaxInputReportSizeResponse>::GetMaxInputReportSize_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMaxInputReportSizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetMaxInputReportSizeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMaxInputReportSizeRequest));
+ ::fidl::DecodedMessage<GetMaxInputReportSizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetMaxInputReportSize(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetMaxInputReportSize Device::SyncClient::GetMaxInputReportSize() {
+ return ResultOf::GetMaxInputReportSize(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetMaxInputReportSize Device::Call::GetMaxInputReportSize(::zx::unowned_channel _client_end) {
+ return ResultOf::GetMaxInputReportSize(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetMaxInputReportSize_Impl<Device::GetMaxInputReportSizeResponse>::GetMaxInputReportSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetMaxInputReportSizeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetMaxInputReportSizeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetMaxInputReportSizeRequest));
+ ::fidl::DecodedMessage<GetMaxInputReportSizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetMaxInputReportSize(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetMaxInputReportSize Device::SyncClient::GetMaxInputReportSize(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMaxInputReportSize(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetMaxInputReportSize Device::Call::GetMaxInputReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMaxInputReportSize(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetMaxInputReportSizeResponse> Device::InPlace::GetMaxInputReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetMaxInputReportSizeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetMaxInputReportSizeRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetMaxInputReportSizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetMaxInputReportSizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetMaxInputReportSizeRequest, GetMaxInputReportSizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetMaxInputReportSizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetReports_Impl<Device::GetReportsResponse>::GetReports_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportsRequest));
+ ::fidl::DecodedMessage<GetReportsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetReports(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetReports Device::SyncClient::GetReports() {
+ return ResultOf::GetReports(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetReports Device::Call::GetReports(::zx::unowned_channel _client_end) {
+ return ResultOf::GetReports(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetReports_Impl<Device::GetReportsResponse>::GetReports_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetReportsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetReportsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetReportsRequest));
+ ::fidl::DecodedMessage<GetReportsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetReports(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetReports Device::SyncClient::GetReports(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReports(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetReports Device::Call::GetReports(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReports(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetReportsResponse> Device::InPlace::GetReports(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetReportsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetReportsRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetReportsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportsRequest, GetReportsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetReportsEvent_Impl<Device::GetReportsEventResponse>::GetReportsEvent_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportsEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportsEventRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportsEventRequest));
+ ::fidl::DecodedMessage<GetReportsEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetReportsEvent(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetReportsEvent Device::SyncClient::GetReportsEvent() {
+ return ResultOf::GetReportsEvent(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetReportsEvent Device::Call::GetReportsEvent(::zx::unowned_channel _client_end) {
+ return ResultOf::GetReportsEvent(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetReportsEvent_Impl<Device::GetReportsEventResponse>::GetReportsEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetReportsEventRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetReportsEventRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetReportsEventRequest));
+ ::fidl::DecodedMessage<GetReportsEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetReportsEvent(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetReportsEvent Device::SyncClient::GetReportsEvent(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportsEvent(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetReportsEvent Device::Call::GetReportsEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReportsEvent(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetReportsEventResponse> Device::InPlace::GetReportsEvent(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetReportsEventRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetReportsEventRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetReportsEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportsEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportsEventRequest, GetReportsEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportsEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetReport_Impl<Device::GetReportResponse>::GetReport_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetReportRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetReportRequest*>(_write_bytes);
+ _request.type = std::move(type);
+ _request.id = std::move(id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportRequest));
+ ::fidl::DecodedMessage<GetReportRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetReport(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetReport Device::SyncClient::GetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
+ return ResultOf::GetReport(::zx::unowned_channel(this->channel_), std::move(type), std::move(id));
+}
+
+Device::ResultOf::GetReport Device::Call::GetReport(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id) {
+ return ResultOf::GetReport(std::move(_client_end), std::move(type), std::move(id));
+}
+
+template <>
+Device::UnownedResultOf::GetReport_Impl<Device::GetReportResponse>::GetReport_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetReportRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetReportResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetReportRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetReportRequest*>(_request_buffer.data());
+ _request.type = std::move(type);
+ _request.id = std::move(id);
+ _request_buffer.set_actual(sizeof(GetReportRequest));
+ ::fidl::DecodedMessage<GetReportRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetReport(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetReport Device::SyncClient::GetReport(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReport(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(id), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetReport Device::Call::GetReport(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetReport(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetReportResponse> Device::InPlace::GetReport(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetReportRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetReportRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetReportRequest, GetReportResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetReportResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetReport_Impl<Device::SetReportResponse>::SetReport_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetReportRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetReportRequest _request = {};
+ _request.type = std::move(type);
+ _request.id = std::move(id);
+ _request.report = std::move(report);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetReportRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::SetReport(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetReport Device::SyncClient::SetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report) {
+ return ResultOf::SetReport(::zx::unowned_channel(this->channel_), std::move(type), std::move(id), std::move(report));
+}
+
+Device::ResultOf::SetReport Device::Call::SetReport(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report) {
+ return ResultOf::SetReport(std::move(_client_end), std::move(type), std::move(id), std::move(report));
+}
+
+template <>
+Device::UnownedResultOf::SetReport_Impl<Device::SetReportResponse>::SetReport_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetReportRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetReportResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetReportRequest _request = {};
+ _request.type = std::move(type);
+ _request.id = std::move(id);
+ _request.report = std::move(report);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetReportRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::SetReport(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetReport Device::SyncClient::SetReport(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetReport(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(type), std::move(id), std::move(report), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetReport Device::Call::SetReport(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetReport(std::move(_client_end), std::move(_request_buffer), std::move(type), std::move(id), std::move(report), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetReportResponse> Device::InPlace::SetReport(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetReportRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetReportRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetReportResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetReportRequest, SetReportResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetReportResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Device::ResultOf::SetTraceId_Impl::SetTraceId_Impl(::zx::unowned_channel _client_end, uint32_t id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTraceIdRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetTraceIdRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetTraceIdRequest*>(_write_bytes);
+ _request.id = std::move(id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTraceIdRequest));
+ ::fidl::DecodedMessage<SetTraceIdRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Device::InPlace::SetTraceId(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::ResultOf::SetTraceId Device::SyncClient::SetTraceId(uint32_t id) {
+ return ResultOf::SetTraceId(::zx::unowned_channel(this->channel_), std::move(id));
+}
+
+Device::ResultOf::SetTraceId Device::Call::SetTraceId(::zx::unowned_channel _client_end, uint32_t id) {
+ return ResultOf::SetTraceId(std::move(_client_end), std::move(id));
+}
+
+
+Device::UnownedResultOf::SetTraceId_Impl::SetTraceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id) {
+ if (_request_buffer.capacity() < SetTraceIdRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetTraceIdRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetTraceIdRequest*>(_request_buffer.data());
+ _request.id = std::move(id);
+ _request_buffer.set_actual(sizeof(SetTraceIdRequest));
+ ::fidl::DecodedMessage<SetTraceIdRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Device::InPlace::SetTraceId(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::UnownedResultOf::SetTraceId Device::SyncClient::SetTraceId(::fidl::BytePart _request_buffer, uint32_t id) {
+ return UnownedResultOf::SetTraceId(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(id));
+}
+
+Device::UnownedResultOf::SetTraceId Device::Call::SetTraceId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id) {
+ return UnownedResultOf::SetTraceId(std::move(_client_end), std::move(_request_buffer), std::move(id));
+}
+
+::fidl::internal::StatusAndError Device::InPlace::SetTraceId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTraceIdRequest> params) {
+ Device::SetTransactionHeaderFor::SetTraceIdRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetBootProtocol_Ordinal:
+ case kDevice_GetBootProtocol_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetBootProtocolRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetBootProtocol(
+ Interface::GetBootProtocolCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetDeviceIds_Ordinal:
+ case kDevice_GetDeviceIds_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDeviceIdsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDeviceIds(
+ Interface::GetDeviceIdsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetReportDescSize_Ordinal:
+ case kDevice_GetReportDescSize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportDescSizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetReportDescSize(
+ Interface::GetReportDescSizeCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetReportDesc_Ordinal:
+ case kDevice_GetReportDesc_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportDescRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetReportDesc(
+ Interface::GetReportDescCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetNumReports_Ordinal:
+ case kDevice_GetNumReports_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNumReportsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetNumReports(
+ Interface::GetNumReportsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetReportIds_Ordinal:
+ case kDevice_GetReportIds_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportIdsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetReportIds(
+ Interface::GetReportIdsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetReportSize_Ordinal:
+ case kDevice_GetReportSize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportSizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetReportSize(std::move(message->type), std::move(message->id),
+ Interface::GetReportSizeCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetMaxInputReportSize_Ordinal:
+ case kDevice_GetMaxInputReportSize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetMaxInputReportSizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetMaxInputReportSize(
+ Interface::GetMaxInputReportSizeCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetReports_Ordinal:
+ case kDevice_GetReports_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetReports(
+ Interface::GetReportsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetReportsEvent_Ordinal:
+ case kDevice_GetReportsEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportsEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetReportsEvent(
+ Interface::GetReportsEventCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetReport_Ordinal:
+ case kDevice_GetReport_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetReportRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetReport(std::move(message->type), std::move(message->id),
+ Interface::GetReportCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetReport_Ordinal:
+ case kDevice_SetReport_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetReportRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetReport(std::move(message->type), std::move(message->id), std::move(message->report),
+ Interface::SetReportCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetTraceId_Ordinal:
+ case kDevice_SetTraceId_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetTraceIdRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetTraceId(std::move(message->id),
+ Interface::SetTraceIdCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetBootProtocolCompleterBase::Reply(::llcpp::fuchsia::hardware::input::BootProtocol protocol) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBootProtocolResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetBootProtocolResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetBootProtocolResponse(
+ ::fidl::DecodedMessage<GetBootProtocolResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBootProtocolResponse::PrimarySize,
+ GetBootProtocolResponse::PrimarySize)));
+ _response.protocol = std::move(protocol);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBootProtocolResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetBootProtocolResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetBootProtocolCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::input::BootProtocol protocol) {
+ if (_buffer.capacity() < GetBootProtocolResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetBootProtocolResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetBootProtocolResponse(
+ ::fidl::DecodedMessage<GetBootProtocolResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBootProtocolResponse::PrimarySize,
+ GetBootProtocolResponse::PrimarySize)));
+ _response.protocol = std::move(protocol);
+ _buffer.set_actual(sizeof(GetBootProtocolResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetBootProtocolResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetBootProtocolCompleterBase::Reply(::fidl::DecodedMessage<GetBootProtocolResponse> params) {
+ Device::SetTransactionHeaderFor::GetBootProtocolResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetDeviceIdsCompleterBase::Reply(::llcpp::fuchsia::hardware::input::DeviceIds ids) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceIdsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetDeviceIdsResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetDeviceIdsResponse(
+ ::fidl::DecodedMessage<GetDeviceIdsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceIdsResponse::PrimarySize,
+ GetDeviceIdsResponse::PrimarySize)));
+ _response.ids = std::move(ids);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceIdsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceIdsResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetDeviceIdsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::input::DeviceIds ids) {
+ if (_buffer.capacity() < GetDeviceIdsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetDeviceIdsResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetDeviceIdsResponse(
+ ::fidl::DecodedMessage<GetDeviceIdsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceIdsResponse::PrimarySize,
+ GetDeviceIdsResponse::PrimarySize)));
+ _response.ids = std::move(ids);
+ _buffer.set_actual(sizeof(GetDeviceIdsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceIdsResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetDeviceIdsCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceIdsResponse> params) {
+ Device::SetTransactionHeaderFor::GetDeviceIdsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetReportDescSizeCompleterBase::Reply(uint16_t size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportDescSizeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetReportDescSizeResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetReportDescSizeResponse(
+ ::fidl::DecodedMessage<GetReportDescSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportDescSizeResponse::PrimarySize,
+ GetReportDescSizeResponse::PrimarySize)));
+ _response.size = std::move(size);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportDescSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetReportDescSizeResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetReportDescSizeCompleterBase::Reply(::fidl::BytePart _buffer, uint16_t size) {
+ if (_buffer.capacity() < GetReportDescSizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetReportDescSizeResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetReportDescSizeResponse(
+ ::fidl::DecodedMessage<GetReportDescSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportDescSizeResponse::PrimarySize,
+ GetReportDescSizeResponse::PrimarySize)));
+ _response.size = std::move(size);
+ _buffer.set_actual(sizeof(GetReportDescSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetReportDescSizeResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetReportDescSizeCompleterBase::Reply(::fidl::DecodedMessage<GetReportDescSizeResponse> params) {
+ Device::SetTransactionHeaderFor::GetReportDescSizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetReportDescCompleterBase::Reply(::fidl::VectorView<uint8_t> desc) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportDescResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetReportDescResponse _response = {};
+ Device::SetTransactionHeaderFor::GetReportDescResponse(
+ ::fidl::DecodedMessage<GetReportDescResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportDescResponse::PrimarySize,
+ GetReportDescResponse::PrimarySize)));
+ _response.desc = std::move(desc);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetReportDescCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> desc) {
+ if (_buffer.capacity() < GetReportDescResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetReportDescResponse _response = {};
+ Device::SetTransactionHeaderFor::GetReportDescResponse(
+ ::fidl::DecodedMessage<GetReportDescResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportDescResponse::PrimarySize,
+ GetReportDescResponse::PrimarySize)));
+ _response.desc = std::move(desc);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetReportDescCompleterBase::Reply(::fidl::DecodedMessage<GetReportDescResponse> params) {
+ Device::SetTransactionHeaderFor::GetReportDescResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetNumReportsCompleterBase::Reply(uint16_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNumReportsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetNumReportsResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetNumReportsResponse(
+ ::fidl::DecodedMessage<GetNumReportsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNumReportsResponse::PrimarySize,
+ GetNumReportsResponse::PrimarySize)));
+ _response.count = std::move(count);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNumReportsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetNumReportsResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetNumReportsCompleterBase::Reply(::fidl::BytePart _buffer, uint16_t count) {
+ if (_buffer.capacity() < GetNumReportsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetNumReportsResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetNumReportsResponse(
+ ::fidl::DecodedMessage<GetNumReportsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNumReportsResponse::PrimarySize,
+ GetNumReportsResponse::PrimarySize)));
+ _response.count = std::move(count);
+ _buffer.set_actual(sizeof(GetNumReportsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetNumReportsResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetNumReportsCompleterBase::Reply(::fidl::DecodedMessage<GetNumReportsResponse> params) {
+ Device::SetTransactionHeaderFor::GetNumReportsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetReportIdsCompleterBase::Reply(::fidl::VectorView<uint8_t> ids) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportIdsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetReportIdsResponse _response = {};
+ Device::SetTransactionHeaderFor::GetReportIdsResponse(
+ ::fidl::DecodedMessage<GetReportIdsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportIdsResponse::PrimarySize,
+ GetReportIdsResponse::PrimarySize)));
+ _response.ids = std::move(ids);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetReportIdsCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> ids) {
+ if (_buffer.capacity() < GetReportIdsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetReportIdsResponse _response = {};
+ Device::SetTransactionHeaderFor::GetReportIdsResponse(
+ ::fidl::DecodedMessage<GetReportIdsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportIdsResponse::PrimarySize,
+ GetReportIdsResponse::PrimarySize)));
+ _response.ids = std::move(ids);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetReportIdsCompleterBase::Reply(::fidl::DecodedMessage<GetReportIdsResponse> params) {
+ Device::SetTransactionHeaderFor::GetReportIdsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetReportSizeCompleterBase::Reply(int32_t status, uint16_t size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportSizeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetReportSizeResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetReportSizeResponse(
+ ::fidl::DecodedMessage<GetReportSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportSizeResponse::PrimarySize,
+ GetReportSizeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.size = std::move(size);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetReportSizeResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetReportSizeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint16_t size) {
+ if (_buffer.capacity() < GetReportSizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetReportSizeResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetReportSizeResponse(
+ ::fidl::DecodedMessage<GetReportSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportSizeResponse::PrimarySize,
+ GetReportSizeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.size = std::move(size);
+ _buffer.set_actual(sizeof(GetReportSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetReportSizeResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetReportSizeCompleterBase::Reply(::fidl::DecodedMessage<GetReportSizeResponse> params) {
+ Device::SetTransactionHeaderFor::GetReportSizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetMaxInputReportSizeCompleterBase::Reply(uint16_t size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMaxInputReportSizeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetMaxInputReportSizeResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetMaxInputReportSizeResponse(
+ ::fidl::DecodedMessage<GetMaxInputReportSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMaxInputReportSizeResponse::PrimarySize,
+ GetMaxInputReportSizeResponse::PrimarySize)));
+ _response.size = std::move(size);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMaxInputReportSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetMaxInputReportSizeResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetMaxInputReportSizeCompleterBase::Reply(::fidl::BytePart _buffer, uint16_t size) {
+ if (_buffer.capacity() < GetMaxInputReportSizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetMaxInputReportSizeResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetMaxInputReportSizeResponse(
+ ::fidl::DecodedMessage<GetMaxInputReportSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMaxInputReportSizeResponse::PrimarySize,
+ GetMaxInputReportSizeResponse::PrimarySize)));
+ _response.size = std::move(size);
+ _buffer.set_actual(sizeof(GetMaxInputReportSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetMaxInputReportSizeResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetMaxInputReportSizeCompleterBase::Reply(::fidl::DecodedMessage<GetMaxInputReportSizeResponse> params) {
+ Device::SetTransactionHeaderFor::GetMaxInputReportSizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetReportsCompleterBase::Reply(int32_t status, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetReportsResponse _response = {};
+ Device::SetTransactionHeaderFor::GetReportsResponse(
+ ::fidl::DecodedMessage<GetReportsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportsResponse::PrimarySize,
+ GetReportsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetReportsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> data) {
+ if (_buffer.capacity() < GetReportsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetReportsResponse _response = {};
+ Device::SetTransactionHeaderFor::GetReportsResponse(
+ ::fidl::DecodedMessage<GetReportsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportsResponse::PrimarySize,
+ GetReportsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetReportsCompleterBase::Reply(::fidl::DecodedMessage<GetReportsResponse> params) {
+ Device::SetTransactionHeaderFor::GetReportsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetReportsEventCompleterBase::Reply(int32_t status, ::zx::event event) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportsEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetReportsEventResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetReportsEventResponse(
+ ::fidl::DecodedMessage<GetReportsEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportsEventResponse::PrimarySize,
+ GetReportsEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.event = std::move(event);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetReportsEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetReportsEventResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetReportsEventCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event event) {
+ if (_buffer.capacity() < GetReportsEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetReportsEventResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetReportsEventResponse(
+ ::fidl::DecodedMessage<GetReportsEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportsEventResponse::PrimarySize,
+ GetReportsEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.event = std::move(event);
+ _buffer.set_actual(sizeof(GetReportsEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetReportsEventResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetReportsEventCompleterBase::Reply(::fidl::DecodedMessage<GetReportsEventResponse> params) {
+ Device::SetTransactionHeaderFor::GetReportsEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetReportCompleterBase::Reply(int32_t status, ::fidl::VectorView<uint8_t> report) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetReportResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetReportResponse _response = {};
+ Device::SetTransactionHeaderFor::GetReportResponse(
+ ::fidl::DecodedMessage<GetReportResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportResponse::PrimarySize,
+ GetReportResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.report = std::move(report);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetReportCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> report) {
+ if (_buffer.capacity() < GetReportResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetReportResponse _response = {};
+ Device::SetTransactionHeaderFor::GetReportResponse(
+ ::fidl::DecodedMessage<GetReportResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetReportResponse::PrimarySize,
+ GetReportResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.report = std::move(report);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetReportCompleterBase::Reply(::fidl::DecodedMessage<GetReportResponse> params) {
+ Device::SetTransactionHeaderFor::GetReportResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetReportCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetReportResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetReportResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetReportResponse(
+ ::fidl::DecodedMessage<SetReportResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetReportResponse::PrimarySize,
+ SetReportResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetReportResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetReportResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetReportCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetReportResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetReportResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetReportResponse(
+ ::fidl::DecodedMessage<SetReportResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetReportResponse::PrimarySize,
+ SetReportResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetReportResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetReportResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetReportCompleterBase::Reply(::fidl::DecodedMessage<SetReportResponse> params) {
+ Device::SetTransactionHeaderFor::SetReportResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetBootProtocolRequest(const ::fidl::DecodedMessage<Device::GetBootProtocolRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetBootProtocol_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetBootProtocolResponse(const ::fidl::DecodedMessage<Device::GetBootProtocolResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetBootProtocol_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetDeviceIdsRequest(const ::fidl::DecodedMessage<Device::GetDeviceIdsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceIds_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetDeviceIdsResponse(const ::fidl::DecodedMessage<Device::GetDeviceIdsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceIds_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetReportDescSizeRequest(const ::fidl::DecodedMessage<Device::GetReportDescSizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportDescSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetReportDescSizeResponse(const ::fidl::DecodedMessage<Device::GetReportDescSizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportDescSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetReportDescRequest(const ::fidl::DecodedMessage<Device::GetReportDescRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportDesc_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetReportDescResponse(const ::fidl::DecodedMessage<Device::GetReportDescResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportDesc_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetNumReportsRequest(const ::fidl::DecodedMessage<Device::GetNumReportsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetNumReports_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetNumReportsResponse(const ::fidl::DecodedMessage<Device::GetNumReportsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetNumReports_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetReportIdsRequest(const ::fidl::DecodedMessage<Device::GetReportIdsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportIds_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetReportIdsResponse(const ::fidl::DecodedMessage<Device::GetReportIdsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportIds_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetReportSizeRequest(const ::fidl::DecodedMessage<Device::GetReportSizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetReportSizeResponse(const ::fidl::DecodedMessage<Device::GetReportSizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetMaxInputReportSizeRequest(const ::fidl::DecodedMessage<Device::GetMaxInputReportSizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetMaxInputReportSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetMaxInputReportSizeResponse(const ::fidl::DecodedMessage<Device::GetMaxInputReportSizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetMaxInputReportSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetReportsRequest(const ::fidl::DecodedMessage<Device::GetReportsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReports_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetReportsResponse(const ::fidl::DecodedMessage<Device::GetReportsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReports_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetReportsEventRequest(const ::fidl::DecodedMessage<Device::GetReportsEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportsEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetReportsEventResponse(const ::fidl::DecodedMessage<Device::GetReportsEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReportsEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetReportRequest(const ::fidl::DecodedMessage<Device::GetReportRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReport_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetReportResponse(const ::fidl::DecodedMessage<Device::GetReportResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetReport_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetReportRequest(const ::fidl::DecodedMessage<Device::SetReportRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetReport_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetReportResponse(const ::fidl::DecodedMessage<Device::SetReportResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetReport_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetTraceIdRequest(const ::fidl::DecodedMessage<Device::SetTraceIdRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetTraceId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace input
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-input/gen/llcpp/include/fuchsia/hardware/input/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-input/gen/llcpp/include/fuchsia/hardware/input/llcpp/fidl.h
new file mode 100644
index 0000000..047a196
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-input/gen/llcpp/include/fuchsia/hardware/input/llcpp/fidl.h
@@ -0,0 +1,1552 @@
+// 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/event.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace input {
+
+enum class ReportType : uint8_t {
+ INPUT = 1u,
+ OUTPUT = 2u,
+ FEATURE = 3u,
+};
+
+
+struct DeviceIds;
+enum class BootProtocol : uint32_t {
+ NONE = 0u,
+ KBD = 1u,
+ MOUSE = 2u,
+};
+
+
+class Device;
+
+constexpr uint16_t MAX_REPORT_LEN = 8192u;
+
+constexpr uint16_t MAX_REPORT_IDS = 256u;
+
+constexpr uint16_t MAX_REPORT_DATA = 8192u;
+
+constexpr uint16_t MAX_DESC_LEN = 8192u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceIdsTable;
+
+// DeviceIds lets a clients determine the vendor and product id for a device.
+// If the device is real HID device, then the id information
+// will come from the device itself. Mock HID devices may assign the
+// ids in the driver. If the mock HID driver does not assign ids, zeros
+// will be used instead.
+struct DeviceIds {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceIdsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 12;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t vendor_id = {};
+
+ uint32_t product_id = {};
+
+ uint32_t version = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetBootProtocolRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetBootProtocolResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetDeviceIdsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetDeviceIdsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescSizeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportDescResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetNumReportsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetNumReportsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportIdsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportIdsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportSizeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportsEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceGetReportResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetReportRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetReportResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetTraceIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_input_DeviceSetTraceIdResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetBootProtocolResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::input::BootProtocol protocol;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetBootProtocolResponseTable;
+ 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 GetBootProtocolRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDeviceIdsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::input::DeviceIds ids;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetDeviceIdsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 GetDeviceIdsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetReportDescSizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint16_t size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportDescSizeResponseTable;
+ 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 GetReportDescSizeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetReportDescResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> desc;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportDescResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 GetReportDescRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetNumReportsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint16_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetNumReportsResponseTable;
+ 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 GetNumReportsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetReportIdsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> ids;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportIdsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 256;
+ 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 GetReportIdsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetReportSizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint16_t size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportSizeResponseTable;
+ 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 GetReportSizeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::input::ReportType type;
+ uint8_t id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportSizeRequestTable;
+ 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 = GetReportSizeResponse;
+ };
+
+ struct GetMaxInputReportSizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint16_t size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetMaxInputReportSizeResponseTable;
+ 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 GetMaxInputReportSizeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetReportsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 GetReportsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetReportsEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::event event;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportsEventResponseTable;
+ 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 GetReportsEventRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetReportResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::fidl::VectorView<uint8_t> report;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 GetReportRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::input::ReportType type;
+ uint8_t id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceGetReportRequestTable;
+ 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 = GetReportResponse;
+ };
+
+ struct SetReportResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceSetReportResponseTable;
+ 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 SetReportRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::input::ReportType type;
+ uint8_t id;
+ ::fidl::VectorView<uint8_t> report;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceSetReportRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = SetReportResponse;
+ };
+
+ struct SetTraceIdRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_input_DeviceSetTraceIdRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetBootProtocol_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetBootProtocol_Impl(::zx::unowned_channel _client_end);
+ ~GetBootProtocol_Impl() = default;
+ GetBootProtocol_Impl(GetBootProtocol_Impl&& other) = default;
+ GetBootProtocol_Impl& operator=(GetBootProtocol_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 GetDeviceIds_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceIds_Impl(::zx::unowned_channel _client_end);
+ ~GetDeviceIds_Impl() = default;
+ GetDeviceIds_Impl(GetDeviceIds_Impl&& other) = default;
+ GetDeviceIds_Impl& operator=(GetDeviceIds_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 GetReportDescSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReportDescSize_Impl(::zx::unowned_channel _client_end);
+ ~GetReportDescSize_Impl() = default;
+ GetReportDescSize_Impl(GetReportDescSize_Impl&& other) = default;
+ GetReportDescSize_Impl& operator=(GetReportDescSize_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 GetReportDesc_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReportDesc_Impl(::zx::unowned_channel _client_end);
+ ~GetReportDesc_Impl() = default;
+ GetReportDesc_Impl(GetReportDesc_Impl&& other) = default;
+ GetReportDesc_Impl& operator=(GetReportDesc_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 GetNumReports_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetNumReports_Impl(::zx::unowned_channel _client_end);
+ ~GetNumReports_Impl() = default;
+ GetNumReports_Impl(GetNumReports_Impl&& other) = default;
+ GetNumReports_Impl& operator=(GetNumReports_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 GetReportIds_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReportIds_Impl(::zx::unowned_channel _client_end);
+ ~GetReportIds_Impl() = default;
+ GetReportIds_Impl(GetReportIds_Impl&& other) = default;
+ GetReportIds_Impl& operator=(GetReportIds_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 GetReportSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReportSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);
+ ~GetReportSize_Impl() = default;
+ GetReportSize_Impl(GetReportSize_Impl&& other) = default;
+ GetReportSize_Impl& operator=(GetReportSize_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 GetMaxInputReportSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetMaxInputReportSize_Impl(::zx::unowned_channel _client_end);
+ ~GetMaxInputReportSize_Impl() = default;
+ GetMaxInputReportSize_Impl(GetMaxInputReportSize_Impl&& other) = default;
+ GetMaxInputReportSize_Impl& operator=(GetMaxInputReportSize_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 GetReports_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReports_Impl(::zx::unowned_channel _client_end);
+ ~GetReports_Impl() = default;
+ GetReports_Impl(GetReports_Impl&& other) = default;
+ GetReports_Impl& operator=(GetReports_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 GetReportsEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReportsEvent_Impl(::zx::unowned_channel _client_end);
+ ~GetReportsEvent_Impl() = default;
+ GetReportsEvent_Impl(GetReportsEvent_Impl&& other) = default;
+ GetReportsEvent_Impl& operator=(GetReportsEvent_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 GetReport_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetReport_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);
+ ~GetReport_Impl() = default;
+ GetReport_Impl(GetReport_Impl&& other) = default;
+ GetReport_Impl& operator=(GetReport_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 SetReport_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetReport_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report);
+ ~SetReport_Impl() = default;
+ SetReport_Impl(SetReport_Impl&& other) = default;
+ SetReport_Impl& operator=(SetReport_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class SetTraceId_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetTraceId_Impl(::zx::unowned_channel _client_end, uint32_t id);
+ ~SetTraceId_Impl() = default;
+ SetTraceId_Impl(SetTraceId_Impl&& other) = default;
+ SetTraceId_Impl& operator=(SetTraceId_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using GetBootProtocol = GetBootProtocol_Impl<GetBootProtocolResponse>;
+ using GetDeviceIds = GetDeviceIds_Impl<GetDeviceIdsResponse>;
+ using GetReportDescSize = GetReportDescSize_Impl<GetReportDescSizeResponse>;
+ using GetReportDesc = GetReportDesc_Impl<GetReportDescResponse>;
+ using GetNumReports = GetNumReports_Impl<GetNumReportsResponse>;
+ using GetReportIds = GetReportIds_Impl<GetReportIdsResponse>;
+ using GetReportSize = GetReportSize_Impl<GetReportSizeResponse>;
+ using GetMaxInputReportSize = GetMaxInputReportSize_Impl<GetMaxInputReportSizeResponse>;
+ using GetReports = GetReports_Impl<GetReportsResponse>;
+ using GetReportsEvent = GetReportsEvent_Impl<GetReportsEventResponse>;
+ using GetReport = GetReport_Impl<GetReportResponse>;
+ using SetReport = SetReport_Impl<SetReportResponse>;
+ using SetTraceId = SetTraceId_Impl;
+ };
+
+ // 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 GetBootProtocol_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetBootProtocol_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetBootProtocol_Impl() = default;
+ GetBootProtocol_Impl(GetBootProtocol_Impl&& other) = default;
+ GetBootProtocol_Impl& operator=(GetBootProtocol_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 GetDeviceIds_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceIds_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDeviceIds_Impl() = default;
+ GetDeviceIds_Impl(GetDeviceIds_Impl&& other) = default;
+ GetDeviceIds_Impl& operator=(GetDeviceIds_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 GetReportDescSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReportDescSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetReportDescSize_Impl() = default;
+ GetReportDescSize_Impl(GetReportDescSize_Impl&& other) = default;
+ GetReportDescSize_Impl& operator=(GetReportDescSize_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 GetReportDesc_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReportDesc_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetReportDesc_Impl() = default;
+ GetReportDesc_Impl(GetReportDesc_Impl&& other) = default;
+ GetReportDesc_Impl& operator=(GetReportDesc_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 GetNumReports_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetNumReports_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetNumReports_Impl() = default;
+ GetNumReports_Impl(GetNumReports_Impl&& other) = default;
+ GetNumReports_Impl& operator=(GetNumReports_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 GetReportIds_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReportIds_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetReportIds_Impl() = default;
+ GetReportIds_Impl(GetReportIds_Impl&& other) = default;
+ GetReportIds_Impl& operator=(GetReportIds_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 GetReportSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReportSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);
+ ~GetReportSize_Impl() = default;
+ GetReportSize_Impl(GetReportSize_Impl&& other) = default;
+ GetReportSize_Impl& operator=(GetReportSize_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 GetMaxInputReportSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetMaxInputReportSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetMaxInputReportSize_Impl() = default;
+ GetMaxInputReportSize_Impl(GetMaxInputReportSize_Impl&& other) = default;
+ GetMaxInputReportSize_Impl& operator=(GetMaxInputReportSize_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 GetReports_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReports_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetReports_Impl() = default;
+ GetReports_Impl(GetReports_Impl&& other) = default;
+ GetReports_Impl& operator=(GetReports_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 GetReportsEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReportsEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetReportsEvent_Impl() = default;
+ GetReportsEvent_Impl(GetReportsEvent_Impl&& other) = default;
+ GetReportsEvent_Impl& operator=(GetReportsEvent_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 GetReport_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetReport_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);
+ ~GetReport_Impl() = default;
+ GetReport_Impl(GetReport_Impl&& other) = default;
+ GetReport_Impl& operator=(GetReport_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 SetReport_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetReport_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer);
+ ~SetReport_Impl() = default;
+ SetReport_Impl(SetReport_Impl&& other) = default;
+ SetReport_Impl& operator=(SetReport_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class SetTraceId_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetTraceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id);
+ ~SetTraceId_Impl() = default;
+ SetTraceId_Impl(SetTraceId_Impl&& other) = default;
+ SetTraceId_Impl& operator=(SetTraceId_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using GetBootProtocol = GetBootProtocol_Impl<GetBootProtocolResponse>;
+ using GetDeviceIds = GetDeviceIds_Impl<GetDeviceIdsResponse>;
+ using GetReportDescSize = GetReportDescSize_Impl<GetReportDescSizeResponse>;
+ using GetReportDesc = GetReportDesc_Impl<GetReportDescResponse>;
+ using GetNumReports = GetNumReports_Impl<GetNumReportsResponse>;
+ using GetReportIds = GetReportIds_Impl<GetReportIdsResponse>;
+ using GetReportSize = GetReportSize_Impl<GetReportSizeResponse>;
+ using GetMaxInputReportSize = GetMaxInputReportSize_Impl<GetMaxInputReportSizeResponse>;
+ using GetReports = GetReports_Impl<GetReportsResponse>;
+ using GetReportsEvent = GetReportsEvent_Impl<GetReportsEventResponse>;
+ using GetReport = GetReport_Impl<GetReportResponse>;
+ using SetReport = SetReport_Impl<SetReportResponse>;
+ using SetTraceId = SetTraceId_Impl;
+ };
+
+ 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_; }
+
+ // Get the HID boot interface protocol this device supports
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetBootProtocol GetBootProtocol();
+
+ // Get the HID boot interface protocol this device supports
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetBootProtocol GetBootProtocol(::fidl::BytePart _response_buffer);
+
+ // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
+ // If it is a mock HID decice, the IDs will either be 0's or user defined.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDeviceIds GetDeviceIds();
+
+ // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
+ // If it is a mock HID decice, the IDs will either be 0's or user defined.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDeviceIds GetDeviceIds(::fidl::BytePart _response_buffer);
+
+ // Get the size of the report descriptor
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetReportDescSize GetReportDescSize();
+
+ // Get the size of the report descriptor
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReportDescSize GetReportDescSize(::fidl::BytePart _response_buffer);
+
+ // Get the report descriptor
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetReportDesc GetReportDesc();
+
+ // Get the report descriptor
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReportDesc GetReportDesc(::fidl::BytePart _response_buffer);
+
+ // Get the number of reports in the report descriptor
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetNumReports GetNumReports();
+
+ // Get the number of reports in the report descriptor
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetNumReports GetNumReports(::fidl::BytePart _response_buffer);
+
+ // Get the report ids that are used in the report descriptor
+ // Allocates 304 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetReportIds GetReportIds();
+
+ // Get the report ids that are used in the report descriptor
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReportIds GetReportIds(::fidl::BytePart _response_buffer);
+
+ // Get the size of a single report for the given (type, id) pair.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetReportSize GetReportSize(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);
+
+ // Get the size of a single report for the given (type, id) pair.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReportSize GetReportSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);
+
+ // Get the maximum size of a single input report.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetMaxInputReportSize GetMaxInputReportSize();
+
+ // Get the maximum size of a single input report.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetMaxInputReportSize GetMaxInputReportSize(::fidl::BytePart _response_buffer);
+
+ // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
+ // This is the interface that is supposed to be used for continuous polling.
+ // Multiple reports can be returned from this API at a time, it is up to the client
+ // to do the parsing of the reports with the correct sizes and offset.
+ // It is guaranteed that only whole reports will be sent.
+ // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
+ // wait on the event from |GetReportsEvent|.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetReports GetReports();
+
+ // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
+ // This is the interface that is supposed to be used for continuous polling.
+ // Multiple reports can be returned from this API at a time, it is up to the client
+ // to do the parsing of the reports with the correct sizes and offset.
+ // It is guaranteed that only whole reports will be sent.
+ // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
+ // wait on the event from |GetReportsEvent|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReports GetReports(::fidl::BytePart _response_buffer);
+
+ // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
+ // Device's report FIFO. This signal will be de-asserted when there are no
+ // reports in the Device's report FIFO. This event can be re-used each time
+ // the client wishes to know if there are reports in the FIFO.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetReportsEvent GetReportsEvent();
+
+ // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
+ // Device's report FIFO. This signal will be de-asserted when there are no
+ // reports in the Device's report FIFO. This event can be re-used each time
+ // the client wishes to know if there are reports in the FIFO.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReportsEvent GetReportsEvent(::fidl::BytePart _response_buffer);
+
+ // Get a single report of the given (type, id) pair. This interface is not intended
+ // to be used for continuous polling of the reports.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetReport GetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);
+
+ // Get a single report of the given (type, id) pair. This interface is not intended
+ // to be used for continuous polling of the reports.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetReport GetReport(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);
+
+ // Set a single report of the given (type, id) pair.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SetReport SetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report);
+
+ // Set a single report of the given (type, id) pair.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetReport SetReport(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer);
+
+ // Set the trace ID that is used for HID report flow events.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetTraceId SetTraceId(uint32_t id);
+
+ // Set the trace ID that is used for HID report flow events.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetTraceId SetTraceId(::fidl::BytePart _request_buffer, uint32_t id);
+
+ 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:
+
+ // Get the HID boot interface protocol this device supports
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetBootProtocol GetBootProtocol(::zx::unowned_channel _client_end);
+
+ // Get the HID boot interface protocol this device supports
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetBootProtocol GetBootProtocol(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
+ // If it is a mock HID decice, the IDs will either be 0's or user defined.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDeviceIds GetDeviceIds(::zx::unowned_channel _client_end);
+
+ // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
+ // If it is a mock HID decice, the IDs will either be 0's or user defined.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDeviceIds GetDeviceIds(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get the size of the report descriptor
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetReportDescSize GetReportDescSize(::zx::unowned_channel _client_end);
+
+ // Get the size of the report descriptor
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReportDescSize GetReportDescSize(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get the report descriptor
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetReportDesc GetReportDesc(::zx::unowned_channel _client_end);
+
+ // Get the report descriptor
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReportDesc GetReportDesc(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get the number of reports in the report descriptor
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetNumReports GetNumReports(::zx::unowned_channel _client_end);
+
+ // Get the number of reports in the report descriptor
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetNumReports GetNumReports(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get the report ids that are used in the report descriptor
+ // Allocates 304 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetReportIds GetReportIds(::zx::unowned_channel _client_end);
+
+ // Get the report ids that are used in the report descriptor
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReportIds GetReportIds(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get the size of a single report for the given (type, id) pair.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetReportSize GetReportSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);
+
+ // Get the size of a single report for the given (type, id) pair.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReportSize GetReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);
+
+ // Get the maximum size of a single input report.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetMaxInputReportSize GetMaxInputReportSize(::zx::unowned_channel _client_end);
+
+ // Get the maximum size of a single input report.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetMaxInputReportSize GetMaxInputReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
+ // This is the interface that is supposed to be used for continuous polling.
+ // Multiple reports can be returned from this API at a time, it is up to the client
+ // to do the parsing of the reports with the correct sizes and offset.
+ // It is guaranteed that only whole reports will be sent.
+ // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
+ // wait on the event from |GetReportsEvent|.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetReports GetReports(::zx::unowned_channel _client_end);
+
+ // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
+ // This is the interface that is supposed to be used for continuous polling.
+ // Multiple reports can be returned from this API at a time, it is up to the client
+ // to do the parsing of the reports with the correct sizes and offset.
+ // It is guaranteed that only whole reports will be sent.
+ // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
+ // wait on the event from |GetReportsEvent|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReports GetReports(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
+ // Device's report FIFO. This signal will be de-asserted when there are no
+ // reports in the Device's report FIFO. This event can be re-used each time
+ // the client wishes to know if there are reports in the FIFO.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetReportsEvent GetReportsEvent(::zx::unowned_channel _client_end);
+
+ // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
+ // Device's report FIFO. This signal will be de-asserted when there are no
+ // reports in the Device's report FIFO. This event can be re-used each time
+ // the client wishes to know if there are reports in the FIFO.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReportsEvent GetReportsEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get a single report of the given (type, id) pair. This interface is not intended
+ // to be used for continuous polling of the reports.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetReport GetReport(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id);
+
+ // Get a single report of the given (type, id) pair. This interface is not intended
+ // to be used for continuous polling of the reports.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetReport GetReport(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::BytePart _response_buffer);
+
+ // Set a single report of the given (type, id) pair.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SetReport SetReport(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report);
+
+ // Set a single report of the given (type, id) pair.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetReport SetReport(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, ::fidl::BytePart _response_buffer);
+
+ // Set the trace ID that is used for HID report flow events.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetTraceId SetTraceId(::zx::unowned_channel _client_end, uint32_t id);
+
+ // Set the trace ID that is used for HID report flow events.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetTraceId SetTraceId(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id);
+
+ };
+
+ // 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:
+
+ // Get the HID boot interface protocol this device supports
+ static ::fidl::DecodeResult<GetBootProtocolResponse> GetBootProtocol(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get the Device's IDs. If this is a real HID device, the IDs will come from the device.
+ // If it is a mock HID decice, the IDs will either be 0's or user defined.
+ static ::fidl::DecodeResult<GetDeviceIdsResponse> GetDeviceIds(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get the size of the report descriptor
+ static ::fidl::DecodeResult<GetReportDescSizeResponse> GetReportDescSize(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get the report descriptor
+ static ::fidl::DecodeResult<GetReportDescResponse> GetReportDesc(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get the number of reports in the report descriptor
+ static ::fidl::DecodeResult<GetNumReportsResponse> GetNumReports(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get the report ids that are used in the report descriptor
+ static ::fidl::DecodeResult<GetReportIdsResponse> GetReportIds(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get the size of a single report for the given (type, id) pair.
+ static ::fidl::DecodeResult<GetReportSizeResponse> GetReportSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetReportSizeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Get the maximum size of a single input report.
+ static ::fidl::DecodeResult<GetMaxInputReportSizeResponse> GetMaxInputReportSize(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Receive up to MAX_REPORT_DATA bytes of reports that have been sent from a device.
+ // This is the interface that is supposed to be used for continuous polling.
+ // Multiple reports can be returned from this API at a time, it is up to the client
+ // to do the parsing of the reports with the correct sizes and offset.
+ // It is guaranteed that only whole reports will be sent.
+ // If there are no reports, this will return ZX_ERR_SHOULD_WAIT, and the client can
+ // wait on the event from |GetReportsEvent|.
+ static ::fidl::DecodeResult<GetReportsResponse> GetReports(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Receive an event that will signal on `ZX_USER_SIGNAL_0` when there are reports in the
+ // Device's report FIFO. This signal will be de-asserted when there are no
+ // reports in the Device's report FIFO. This event can be re-used each time
+ // the client wishes to know if there are reports in the FIFO.
+ static ::fidl::DecodeResult<GetReportsEventResponse> GetReportsEvent(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get a single report of the given (type, id) pair. This interface is not intended
+ // to be used for continuous polling of the reports.
+ static ::fidl::DecodeResult<GetReportResponse> GetReport(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetReportRequest> params, ::fidl::BytePart response_buffer);
+
+ // Set a single report of the given (type, id) pair.
+ static ::fidl::DecodeResult<SetReportResponse> SetReport(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetReportRequest> params, ::fidl::BytePart response_buffer);
+
+ // Set the trace ID that is used for HID report flow events.
+ static ::fidl::internal::StatusAndError SetTraceId(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTraceIdRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetBootProtocolCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::input::BootProtocol protocol);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::input::BootProtocol protocol);
+ void Reply(::fidl::DecodedMessage<GetBootProtocolResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetBootProtocolCompleter = ::fidl::Completer<GetBootProtocolCompleterBase>;
+
+ virtual void GetBootProtocol(GetBootProtocolCompleter::Sync _completer) = 0;
+
+ class GetDeviceIdsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::input::DeviceIds ids);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::input::DeviceIds ids);
+ void Reply(::fidl::DecodedMessage<GetDeviceIdsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDeviceIdsCompleter = ::fidl::Completer<GetDeviceIdsCompleterBase>;
+
+ virtual void GetDeviceIds(GetDeviceIdsCompleter::Sync _completer) = 0;
+
+ class GetReportDescSizeCompleterBase : public _Base {
+ public:
+ void Reply(uint16_t size);
+ void Reply(::fidl::BytePart _buffer, uint16_t size);
+ void Reply(::fidl::DecodedMessage<GetReportDescSizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportDescSizeCompleter = ::fidl::Completer<GetReportDescSizeCompleterBase>;
+
+ virtual void GetReportDescSize(GetReportDescSizeCompleter::Sync _completer) = 0;
+
+ class GetReportDescCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<uint8_t> desc);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> desc);
+ void Reply(::fidl::DecodedMessage<GetReportDescResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportDescCompleter = ::fidl::Completer<GetReportDescCompleterBase>;
+
+ virtual void GetReportDesc(GetReportDescCompleter::Sync _completer) = 0;
+
+ class GetNumReportsCompleterBase : public _Base {
+ public:
+ void Reply(uint16_t count);
+ void Reply(::fidl::BytePart _buffer, uint16_t count);
+ void Reply(::fidl::DecodedMessage<GetNumReportsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetNumReportsCompleter = ::fidl::Completer<GetNumReportsCompleterBase>;
+
+ virtual void GetNumReports(GetNumReportsCompleter::Sync _completer) = 0;
+
+ class GetReportIdsCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<uint8_t> ids);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> ids);
+ void Reply(::fidl::DecodedMessage<GetReportIdsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportIdsCompleter = ::fidl::Completer<GetReportIdsCompleterBase>;
+
+ virtual void GetReportIds(GetReportIdsCompleter::Sync _completer) = 0;
+
+ class GetReportSizeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint16_t size);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint16_t size);
+ void Reply(::fidl::DecodedMessage<GetReportSizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportSizeCompleter = ::fidl::Completer<GetReportSizeCompleterBase>;
+
+ virtual void GetReportSize(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, GetReportSizeCompleter::Sync _completer) = 0;
+
+ class GetMaxInputReportSizeCompleterBase : public _Base {
+ public:
+ void Reply(uint16_t size);
+ void Reply(::fidl::BytePart _buffer, uint16_t size);
+ void Reply(::fidl::DecodedMessage<GetMaxInputReportSizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetMaxInputReportSizeCompleter = ::fidl::Completer<GetMaxInputReportSizeCompleterBase>;
+
+ virtual void GetMaxInputReportSize(GetMaxInputReportSizeCompleter::Sync _completer) = 0;
+
+ class GetReportsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<GetReportsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportsCompleter = ::fidl::Completer<GetReportsCompleterBase>;
+
+ virtual void GetReports(GetReportsCompleter::Sync _completer) = 0;
+
+ class GetReportsEventCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::event event);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event event);
+ void Reply(::fidl::DecodedMessage<GetReportsEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportsEventCompleter = ::fidl::Completer<GetReportsEventCompleterBase>;
+
+ virtual void GetReportsEvent(GetReportsEventCompleter::Sync _completer) = 0;
+
+ class GetReportCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::fidl::VectorView<uint8_t> report);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> report);
+ void Reply(::fidl::DecodedMessage<GetReportResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetReportCompleter = ::fidl::Completer<GetReportCompleterBase>;
+
+ virtual void GetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, GetReportCompleter::Sync _completer) = 0;
+
+ class SetReportCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetReportResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetReportCompleter = ::fidl::Completer<SetReportCompleterBase>;
+
+ virtual void SetReport(::llcpp::fuchsia::hardware::input::ReportType type, uint8_t id, ::fidl::VectorView<uint8_t> report, SetReportCompleter::Sync _completer) = 0;
+
+ using SetTraceIdCompleter = ::fidl::Completer<>;
+
+ virtual void SetTraceId(uint32_t id, SetTraceIdCompleter::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 GetBootProtocolRequest(const ::fidl::DecodedMessage<Device::GetBootProtocolRequest>& _msg);
+ static void GetBootProtocolResponse(const ::fidl::DecodedMessage<Device::GetBootProtocolResponse>& _msg);
+ static void GetDeviceIdsRequest(const ::fidl::DecodedMessage<Device::GetDeviceIdsRequest>& _msg);
+ static void GetDeviceIdsResponse(const ::fidl::DecodedMessage<Device::GetDeviceIdsResponse>& _msg);
+ static void GetReportDescSizeRequest(const ::fidl::DecodedMessage<Device::GetReportDescSizeRequest>& _msg);
+ static void GetReportDescSizeResponse(const ::fidl::DecodedMessage<Device::GetReportDescSizeResponse>& _msg);
+ static void GetReportDescRequest(const ::fidl::DecodedMessage<Device::GetReportDescRequest>& _msg);
+ static void GetReportDescResponse(const ::fidl::DecodedMessage<Device::GetReportDescResponse>& _msg);
+ static void GetNumReportsRequest(const ::fidl::DecodedMessage<Device::GetNumReportsRequest>& _msg);
+ static void GetNumReportsResponse(const ::fidl::DecodedMessage<Device::GetNumReportsResponse>& _msg);
+ static void GetReportIdsRequest(const ::fidl::DecodedMessage<Device::GetReportIdsRequest>& _msg);
+ static void GetReportIdsResponse(const ::fidl::DecodedMessage<Device::GetReportIdsResponse>& _msg);
+ static void GetReportSizeRequest(const ::fidl::DecodedMessage<Device::GetReportSizeRequest>& _msg);
+ static void GetReportSizeResponse(const ::fidl::DecodedMessage<Device::GetReportSizeResponse>& _msg);
+ static void GetMaxInputReportSizeRequest(const ::fidl::DecodedMessage<Device::GetMaxInputReportSizeRequest>& _msg);
+ static void GetMaxInputReportSizeResponse(const ::fidl::DecodedMessage<Device::GetMaxInputReportSizeResponse>& _msg);
+ static void GetReportsRequest(const ::fidl::DecodedMessage<Device::GetReportsRequest>& _msg);
+ static void GetReportsResponse(const ::fidl::DecodedMessage<Device::GetReportsResponse>& _msg);
+ static void GetReportsEventRequest(const ::fidl::DecodedMessage<Device::GetReportsEventRequest>& _msg);
+ static void GetReportsEventResponse(const ::fidl::DecodedMessage<Device::GetReportsEventResponse>& _msg);
+ static void GetReportRequest(const ::fidl::DecodedMessage<Device::GetReportRequest>& _msg);
+ static void GetReportResponse(const ::fidl::DecodedMessage<Device::GetReportResponse>& _msg);
+ static void SetReportRequest(const ::fidl::DecodedMessage<Device::SetReportRequest>& _msg);
+ static void SetReportResponse(const ::fidl::DecodedMessage<Device::SetReportResponse>& _msg);
+ static void SetTraceIdRequest(const ::fidl::DecodedMessage<Device::SetTraceIdRequest>& _msg);
+ };
+};
+
+} // namespace input
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::DeviceIds> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::input::DeviceIds>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::DeviceIds, vendor_id) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::DeviceIds, product_id) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::DeviceIds, version) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::DeviceIds) == ::llcpp::fuchsia::hardware::input::DeviceIds::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetBootProtocolResponse, protocol) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetDeviceIdsResponse, ids) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportDescSizeResponse, size) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportDescResponse, desc) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetNumReportsResponse, count) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportIdsResponse, ids) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest, type) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeRequest, id) == 17);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportSizeResponse, size) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetMaxInputReportSizeResponse, size) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportsResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportsResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportsResponse, data) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportsEventResponse, event) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportRequest)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportRequest, type) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportRequest, id) == 17);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::GetReportResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::GetReportResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::GetReportResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::GetReportResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::GetReportResponse, report) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::SetReportRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::SetReportRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::SetReportRequest)
+ == ::llcpp::fuchsia::hardware::input::Device::SetReportRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetReportRequest, type) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetReportRequest, id) == 17);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetReportRequest, report) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::SetReportResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::SetReportResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::SetReportResponse)
+ == ::llcpp::fuchsia::hardware::input::Device::SetReportResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetReportResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest)
+ == ::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::input::Device::SetTraceIdRequest, id) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-light/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-light/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..a95d057
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-light/gen/llcpp/fidl.cc
@@ -0,0 +1,953 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/light/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace light {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLight_GetName_Ordinal = 0x9d4dbd800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLight_GetName_GenOrdinal = 0x14a083e18eeca03dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLight_GetCount_Ordinal = 0x4e441b4600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLight_GetCount_GenOrdinal = 0x3f141dbdbcb1f0felu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetCountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetCountResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLight_HasCapability_Ordinal = 0x703098f200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLight_HasCapability_GenOrdinal = 0x6fb1d40c2effffc9lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightHasCapabilityRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightHasCapabilityResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLight_GetSimpleValue_Ordinal = 0x634b636200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLight_GetSimpleValue_GenOrdinal = 0x30826e9255b5a9e3lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetSimpleValueRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetSimpleValueResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLight_SetSimpleValue_Ordinal = 0x56deecd500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLight_SetSimpleValue_GenOrdinal = 0x4fb33d84c1aad81dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightSetSimpleValueRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightSetSimpleValueResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLight_GetRgbValue_Ordinal = 0xf37a4e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLight_GetRgbValue_GenOrdinal = 0x57f15472f735669dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetRgbValueRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetRgbValueResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLight_SetRgbValue_Ordinal = 0x81b4c9b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLight_SetRgbValue_GenOrdinal = 0x2b354d18be0b70a4lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightSetRgbValueRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightSetRgbValueResponseTable;
+
+} // namespace
+template <>
+Light::ResultOf::GetName_Impl<Light::GetNameResponse>::GetName_Impl(::zx::unowned_channel _client_end, uint32_t index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNameRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetNameRequest*>(_write_bytes);
+ _request.index = std::move(index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNameRequest));
+ ::fidl::DecodedMessage<GetNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Light::InPlace::GetName(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Light::ResultOf::GetName Light::SyncClient::GetName(uint32_t index) {
+ return ResultOf::GetName(::zx::unowned_channel(this->channel_), std::move(index));
+}
+
+Light::ResultOf::GetName Light::Call::GetName(::zx::unowned_channel _client_end, uint32_t index) {
+ return ResultOf::GetName(std::move(_client_end), std::move(index));
+}
+
+template <>
+Light::UnownedResultOf::GetName_Impl<Light::GetNameResponse>::GetName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetNameRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetNameResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetNameRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetNameRequest*>(_request_buffer.data());
+ _request.index = std::move(index);
+ _request_buffer.set_actual(sizeof(GetNameRequest));
+ ::fidl::DecodedMessage<GetNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Light::InPlace::GetName(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Light::UnownedResultOf::GetName Light::SyncClient::GetName(::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetName(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(index), std::move(_response_buffer));
+}
+
+Light::UnownedResultOf::GetName Light::Call::GetName(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetName(std::move(_client_end), std::move(_request_buffer), std::move(index), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Light::GetNameResponse> Light::InPlace::GetName(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetNameRequest> params, ::fidl::BytePart response_buffer) {
+ Light::SetTransactionHeaderFor::GetNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::GetNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNameRequest, GetNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::GetNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Light::ResultOf::GetCount_Impl<Light::GetCountResponse>::GetCount_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCountRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetCountRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCountRequest));
+ ::fidl::DecodedMessage<GetCountRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Light::InPlace::GetCount(std::move(_client_end), Super::response_buffer()));
+}
+
+Light::ResultOf::GetCount Light::SyncClient::GetCount() {
+ return ResultOf::GetCount(::zx::unowned_channel(this->channel_));
+}
+
+Light::ResultOf::GetCount Light::Call::GetCount(::zx::unowned_channel _client_end) {
+ return ResultOf::GetCount(std::move(_client_end));
+}
+
+template <>
+Light::UnownedResultOf::GetCount_Impl<Light::GetCountResponse>::GetCount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetCountRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetCountRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetCountRequest));
+ ::fidl::DecodedMessage<GetCountRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Light::InPlace::GetCount(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Light::UnownedResultOf::GetCount Light::SyncClient::GetCount(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCount(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Light::UnownedResultOf::GetCount Light::Call::GetCount(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCount(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Light::GetCountResponse> Light::InPlace::GetCount(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetCountRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetCountRequest> params(std::move(_request_buffer));
+ Light::SetTransactionHeaderFor::GetCountRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::GetCountResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetCountRequest, GetCountResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::GetCountResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Light::ResultOf::HasCapability_Impl<Light::HasCapabilityResponse>::HasCapability_Impl(::zx::unowned_channel _client_end, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<HasCapabilityRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, HasCapabilityRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<HasCapabilityRequest*>(_write_bytes);
+ _request.index = std::move(index);
+ _request.capability = std::move(capability);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(HasCapabilityRequest));
+ ::fidl::DecodedMessage<HasCapabilityRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Light::InPlace::HasCapability(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Light::ResultOf::HasCapability Light::SyncClient::HasCapability(uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability) {
+ return ResultOf::HasCapability(::zx::unowned_channel(this->channel_), std::move(index), std::move(capability));
+}
+
+Light::ResultOf::HasCapability Light::Call::HasCapability(::zx::unowned_channel _client_end, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability) {
+ return ResultOf::HasCapability(std::move(_client_end), std::move(index), std::move(capability));
+}
+
+template <>
+Light::UnownedResultOf::HasCapability_Impl<Light::HasCapabilityResponse>::HasCapability_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < HasCapabilityRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<HasCapabilityResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, HasCapabilityRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<HasCapabilityRequest*>(_request_buffer.data());
+ _request.index = std::move(index);
+ _request.capability = std::move(capability);
+ _request_buffer.set_actual(sizeof(HasCapabilityRequest));
+ ::fidl::DecodedMessage<HasCapabilityRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Light::InPlace::HasCapability(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Light::UnownedResultOf::HasCapability Light::SyncClient::HasCapability(::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::HasCapability(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(index), std::move(capability), std::move(_response_buffer));
+}
+
+Light::UnownedResultOf::HasCapability Light::Call::HasCapability(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::HasCapability(std::move(_client_end), std::move(_request_buffer), std::move(index), std::move(capability), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Light::HasCapabilityResponse> Light::InPlace::HasCapability(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<HasCapabilityRequest> params, ::fidl::BytePart response_buffer) {
+ Light::SetTransactionHeaderFor::HasCapabilityRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::HasCapabilityResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<HasCapabilityRequest, HasCapabilityResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::HasCapabilityResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Light::ResultOf::GetSimpleValue_Impl<Light::GetSimpleValueResponse>::GetSimpleValue_Impl(::zx::unowned_channel _client_end, uint32_t index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSimpleValueRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSimpleValueRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSimpleValueRequest*>(_write_bytes);
+ _request.index = std::move(index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSimpleValueRequest));
+ ::fidl::DecodedMessage<GetSimpleValueRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Light::InPlace::GetSimpleValue(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Light::ResultOf::GetSimpleValue Light::SyncClient::GetSimpleValue(uint32_t index) {
+ return ResultOf::GetSimpleValue(::zx::unowned_channel(this->channel_), std::move(index));
+}
+
+Light::ResultOf::GetSimpleValue Light::Call::GetSimpleValue(::zx::unowned_channel _client_end, uint32_t index) {
+ return ResultOf::GetSimpleValue(std::move(_client_end), std::move(index));
+}
+
+template <>
+Light::UnownedResultOf::GetSimpleValue_Impl<Light::GetSimpleValueResponse>::GetSimpleValue_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetSimpleValueRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetSimpleValueResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetSimpleValueRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSimpleValueRequest*>(_request_buffer.data());
+ _request.index = std::move(index);
+ _request_buffer.set_actual(sizeof(GetSimpleValueRequest));
+ ::fidl::DecodedMessage<GetSimpleValueRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Light::InPlace::GetSimpleValue(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Light::UnownedResultOf::GetSimpleValue Light::SyncClient::GetSimpleValue(::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSimpleValue(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(index), std::move(_response_buffer));
+}
+
+Light::UnownedResultOf::GetSimpleValue Light::Call::GetSimpleValue(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSimpleValue(std::move(_client_end), std::move(_request_buffer), std::move(index), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Light::GetSimpleValueResponse> Light::InPlace::GetSimpleValue(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSimpleValueRequest> params, ::fidl::BytePart response_buffer) {
+ Light::SetTransactionHeaderFor::GetSimpleValueRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::GetSimpleValueResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSimpleValueRequest, GetSimpleValueResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::GetSimpleValueResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Light::ResultOf::SetSimpleValue_Impl<Light::SetSimpleValueResponse>::SetSimpleValue_Impl(::zx::unowned_channel _client_end, uint32_t index, uint8_t value) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSimpleValueRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetSimpleValueRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetSimpleValueRequest*>(_write_bytes);
+ _request.index = std::move(index);
+ _request.value = std::move(value);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetSimpleValueRequest));
+ ::fidl::DecodedMessage<SetSimpleValueRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Light::InPlace::SetSimpleValue(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Light::ResultOf::SetSimpleValue Light::SyncClient::SetSimpleValue(uint32_t index, uint8_t value) {
+ return ResultOf::SetSimpleValue(::zx::unowned_channel(this->channel_), std::move(index), std::move(value));
+}
+
+Light::ResultOf::SetSimpleValue Light::Call::SetSimpleValue(::zx::unowned_channel _client_end, uint32_t index, uint8_t value) {
+ return ResultOf::SetSimpleValue(std::move(_client_end), std::move(index), std::move(value));
+}
+
+template <>
+Light::UnownedResultOf::SetSimpleValue_Impl<Light::SetSimpleValueResponse>::SetSimpleValue_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, uint8_t value, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetSimpleValueRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetSimpleValueResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetSimpleValueRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetSimpleValueRequest*>(_request_buffer.data());
+ _request.index = std::move(index);
+ _request.value = std::move(value);
+ _request_buffer.set_actual(sizeof(SetSimpleValueRequest));
+ ::fidl::DecodedMessage<SetSimpleValueRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Light::InPlace::SetSimpleValue(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Light::UnownedResultOf::SetSimpleValue Light::SyncClient::SetSimpleValue(::fidl::BytePart _request_buffer, uint32_t index, uint8_t value, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSimpleValue(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(index), std::move(value), std::move(_response_buffer));
+}
+
+Light::UnownedResultOf::SetSimpleValue Light::Call::SetSimpleValue(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, uint8_t value, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSimpleValue(std::move(_client_end), std::move(_request_buffer), std::move(index), std::move(value), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Light::SetSimpleValueResponse> Light::InPlace::SetSimpleValue(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSimpleValueRequest> params, ::fidl::BytePart response_buffer) {
+ Light::SetTransactionHeaderFor::SetSimpleValueRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::SetSimpleValueResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetSimpleValueRequest, SetSimpleValueResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::SetSimpleValueResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Light::ResultOf::GetRgbValue_Impl<Light::GetRgbValueResponse>::GetRgbValue_Impl(::zx::unowned_channel _client_end, uint32_t index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRgbValueRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetRgbValueRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetRgbValueRequest*>(_write_bytes);
+ _request.index = std::move(index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRgbValueRequest));
+ ::fidl::DecodedMessage<GetRgbValueRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Light::InPlace::GetRgbValue(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Light::ResultOf::GetRgbValue Light::SyncClient::GetRgbValue(uint32_t index) {
+ return ResultOf::GetRgbValue(::zx::unowned_channel(this->channel_), std::move(index));
+}
+
+Light::ResultOf::GetRgbValue Light::Call::GetRgbValue(::zx::unowned_channel _client_end, uint32_t index) {
+ return ResultOf::GetRgbValue(std::move(_client_end), std::move(index));
+}
+
+template <>
+Light::UnownedResultOf::GetRgbValue_Impl<Light::GetRgbValueResponse>::GetRgbValue_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetRgbValueRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetRgbValueResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetRgbValueRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetRgbValueRequest*>(_request_buffer.data());
+ _request.index = std::move(index);
+ _request_buffer.set_actual(sizeof(GetRgbValueRequest));
+ ::fidl::DecodedMessage<GetRgbValueRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Light::InPlace::GetRgbValue(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Light::UnownedResultOf::GetRgbValue Light::SyncClient::GetRgbValue(::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetRgbValue(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(index), std::move(_response_buffer));
+}
+
+Light::UnownedResultOf::GetRgbValue Light::Call::GetRgbValue(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetRgbValue(std::move(_client_end), std::move(_request_buffer), std::move(index), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Light::GetRgbValueResponse> Light::InPlace::GetRgbValue(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetRgbValueRequest> params, ::fidl::BytePart response_buffer) {
+ Light::SetTransactionHeaderFor::GetRgbValueRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::GetRgbValueResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetRgbValueRequest, GetRgbValueResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::GetRgbValueResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Light::ResultOf::SetRgbValue_Impl<Light::SetRgbValueResponse>::SetRgbValue_Impl(::zx::unowned_channel _client_end, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetRgbValueRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetRgbValueRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetRgbValueRequest*>(_write_bytes);
+ _request.index = std::move(index);
+ _request.value = std::move(value);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetRgbValueRequest));
+ ::fidl::DecodedMessage<SetRgbValueRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Light::InPlace::SetRgbValue(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Light::ResultOf::SetRgbValue Light::SyncClient::SetRgbValue(uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value) {
+ return ResultOf::SetRgbValue(::zx::unowned_channel(this->channel_), std::move(index), std::move(value));
+}
+
+Light::ResultOf::SetRgbValue Light::Call::SetRgbValue(::zx::unowned_channel _client_end, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value) {
+ return ResultOf::SetRgbValue(std::move(_client_end), std::move(index), std::move(value));
+}
+
+template <>
+Light::UnownedResultOf::SetRgbValue_Impl<Light::SetRgbValueResponse>::SetRgbValue_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetRgbValueRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetRgbValueResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetRgbValueRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetRgbValueRequest*>(_request_buffer.data());
+ _request.index = std::move(index);
+ _request.value = std::move(value);
+ _request_buffer.set_actual(sizeof(SetRgbValueRequest));
+ ::fidl::DecodedMessage<SetRgbValueRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Light::InPlace::SetRgbValue(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Light::UnownedResultOf::SetRgbValue Light::SyncClient::SetRgbValue(::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetRgbValue(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(index), std::move(value), std::move(_response_buffer));
+}
+
+Light::UnownedResultOf::SetRgbValue Light::Call::SetRgbValue(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetRgbValue(std::move(_client_end), std::move(_request_buffer), std::move(index), std::move(value), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Light::SetRgbValueResponse> Light::InPlace::SetRgbValue(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetRgbValueRequest> params, ::fidl::BytePart response_buffer) {
+ Light::SetTransactionHeaderFor::SetRgbValueRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::SetRgbValueResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetRgbValueRequest, SetRgbValueResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Light::SetRgbValueResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Light::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kLight_GetName_Ordinal:
+ case kLight_GetName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetName(std::move(message->index),
+ Interface::GetNameCompleter::Sync(txn));
+ return true;
+ }
+ case kLight_GetCount_Ordinal:
+ case kLight_GetCount_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetCountRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetCount(
+ Interface::GetCountCompleter::Sync(txn));
+ return true;
+ }
+ case kLight_HasCapability_Ordinal:
+ case kLight_HasCapability_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<HasCapabilityRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->HasCapability(std::move(message->index), std::move(message->capability),
+ Interface::HasCapabilityCompleter::Sync(txn));
+ return true;
+ }
+ case kLight_GetSimpleValue_Ordinal:
+ case kLight_GetSimpleValue_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSimpleValueRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetSimpleValue(std::move(message->index),
+ Interface::GetSimpleValueCompleter::Sync(txn));
+ return true;
+ }
+ case kLight_SetSimpleValue_Ordinal:
+ case kLight_SetSimpleValue_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetSimpleValueRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetSimpleValue(std::move(message->index), std::move(message->value),
+ Interface::SetSimpleValueCompleter::Sync(txn));
+ return true;
+ }
+ case kLight_GetRgbValue_Ordinal:
+ case kLight_GetRgbValue_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetRgbValueRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetRgbValue(std::move(message->index),
+ Interface::GetRgbValueCompleter::Sync(txn));
+ return true;
+ }
+ case kLight_SetRgbValue_Ordinal:
+ case kLight_SetRgbValue_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetRgbValueRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetRgbValue(std::move(message->index), std::move(message->value),
+ Interface::SetRgbValueCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Light::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Light::Interface::GetNameCompleterBase::Reply(int32_t status, ::fidl::StringView name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetNameResponse _response = {};
+ Light::SetTransactionHeaderFor::GetNameResponse(
+ ::fidl::DecodedMessage<GetNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNameResponse::PrimarySize,
+ GetNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Light::Interface::GetNameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::StringView name) {
+ if (_buffer.capacity() < GetNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetNameResponse _response = {};
+ Light::SetTransactionHeaderFor::GetNameResponse(
+ ::fidl::DecodedMessage<GetNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNameResponse::PrimarySize,
+ GetNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Light::Interface::GetNameCompleterBase::Reply(::fidl::DecodedMessage<GetNameResponse> params) {
+ Light::SetTransactionHeaderFor::GetNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Light::Interface::GetCountCompleterBase::Reply(uint32_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCountResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetCountResponse*>(_write_bytes);
+ Light::SetTransactionHeaderFor::GetCountResponse(
+ ::fidl::DecodedMessage<GetCountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCountResponse::PrimarySize,
+ GetCountResponse::PrimarySize)));
+ _response.count = std::move(count);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetCountResponse>(std::move(_response_bytes)));
+}
+
+void Light::Interface::GetCountCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t count) {
+ if (_buffer.capacity() < GetCountResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetCountResponse*>(_buffer.data());
+ Light::SetTransactionHeaderFor::GetCountResponse(
+ ::fidl::DecodedMessage<GetCountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCountResponse::PrimarySize,
+ GetCountResponse::PrimarySize)));
+ _response.count = std::move(count);
+ _buffer.set_actual(sizeof(GetCountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetCountResponse>(std::move(_buffer)));
+}
+
+void Light::Interface::GetCountCompleterBase::Reply(::fidl::DecodedMessage<GetCountResponse> params) {
+ Light::SetTransactionHeaderFor::GetCountResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Light::Interface::HasCapabilityCompleterBase::Reply(int32_t status, bool has) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<HasCapabilityResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<HasCapabilityResponse*>(_write_bytes);
+ Light::SetTransactionHeaderFor::HasCapabilityResponse(
+ ::fidl::DecodedMessage<HasCapabilityResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ HasCapabilityResponse::PrimarySize,
+ HasCapabilityResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.has = std::move(has);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(HasCapabilityResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<HasCapabilityResponse>(std::move(_response_bytes)));
+}
+
+void Light::Interface::HasCapabilityCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, bool has) {
+ if (_buffer.capacity() < HasCapabilityResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<HasCapabilityResponse*>(_buffer.data());
+ Light::SetTransactionHeaderFor::HasCapabilityResponse(
+ ::fidl::DecodedMessage<HasCapabilityResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ HasCapabilityResponse::PrimarySize,
+ HasCapabilityResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.has = std::move(has);
+ _buffer.set_actual(sizeof(HasCapabilityResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<HasCapabilityResponse>(std::move(_buffer)));
+}
+
+void Light::Interface::HasCapabilityCompleterBase::Reply(::fidl::DecodedMessage<HasCapabilityResponse> params) {
+ Light::SetTransactionHeaderFor::HasCapabilityResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Light::Interface::GetSimpleValueCompleterBase::Reply(int32_t status, uint8_t value) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSimpleValueResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetSimpleValueResponse*>(_write_bytes);
+ Light::SetTransactionHeaderFor::GetSimpleValueResponse(
+ ::fidl::DecodedMessage<GetSimpleValueResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSimpleValueResponse::PrimarySize,
+ GetSimpleValueResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.value = std::move(value);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSimpleValueResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetSimpleValueResponse>(std::move(_response_bytes)));
+}
+
+void Light::Interface::GetSimpleValueCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint8_t value) {
+ if (_buffer.capacity() < GetSimpleValueResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetSimpleValueResponse*>(_buffer.data());
+ Light::SetTransactionHeaderFor::GetSimpleValueResponse(
+ ::fidl::DecodedMessage<GetSimpleValueResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSimpleValueResponse::PrimarySize,
+ GetSimpleValueResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.value = std::move(value);
+ _buffer.set_actual(sizeof(GetSimpleValueResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetSimpleValueResponse>(std::move(_buffer)));
+}
+
+void Light::Interface::GetSimpleValueCompleterBase::Reply(::fidl::DecodedMessage<GetSimpleValueResponse> params) {
+ Light::SetTransactionHeaderFor::GetSimpleValueResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Light::Interface::SetSimpleValueCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSimpleValueResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetSimpleValueResponse*>(_write_bytes);
+ Light::SetTransactionHeaderFor::SetSimpleValueResponse(
+ ::fidl::DecodedMessage<SetSimpleValueResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSimpleValueResponse::PrimarySize,
+ SetSimpleValueResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetSimpleValueResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetSimpleValueResponse>(std::move(_response_bytes)));
+}
+
+void Light::Interface::SetSimpleValueCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetSimpleValueResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetSimpleValueResponse*>(_buffer.data());
+ Light::SetTransactionHeaderFor::SetSimpleValueResponse(
+ ::fidl::DecodedMessage<SetSimpleValueResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSimpleValueResponse::PrimarySize,
+ SetSimpleValueResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetSimpleValueResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetSimpleValueResponse>(std::move(_buffer)));
+}
+
+void Light::Interface::SetSimpleValueCompleterBase::Reply(::fidl::DecodedMessage<SetSimpleValueResponse> params) {
+ Light::SetTransactionHeaderFor::SetSimpleValueResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Light::Interface::GetRgbValueCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::light::Rgb value) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetRgbValueResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetRgbValueResponse*>(_write_bytes);
+ Light::SetTransactionHeaderFor::GetRgbValueResponse(
+ ::fidl::DecodedMessage<GetRgbValueResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetRgbValueResponse::PrimarySize,
+ GetRgbValueResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.value = std::move(value);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetRgbValueResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetRgbValueResponse>(std::move(_response_bytes)));
+}
+
+void Light::Interface::GetRgbValueCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::light::Rgb value) {
+ if (_buffer.capacity() < GetRgbValueResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetRgbValueResponse*>(_buffer.data());
+ Light::SetTransactionHeaderFor::GetRgbValueResponse(
+ ::fidl::DecodedMessage<GetRgbValueResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetRgbValueResponse::PrimarySize,
+ GetRgbValueResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.value = std::move(value);
+ _buffer.set_actual(sizeof(GetRgbValueResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetRgbValueResponse>(std::move(_buffer)));
+}
+
+void Light::Interface::GetRgbValueCompleterBase::Reply(::fidl::DecodedMessage<GetRgbValueResponse> params) {
+ Light::SetTransactionHeaderFor::GetRgbValueResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Light::Interface::SetRgbValueCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetRgbValueResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetRgbValueResponse*>(_write_bytes);
+ Light::SetTransactionHeaderFor::SetRgbValueResponse(
+ ::fidl::DecodedMessage<SetRgbValueResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetRgbValueResponse::PrimarySize,
+ SetRgbValueResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetRgbValueResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetRgbValueResponse>(std::move(_response_bytes)));
+}
+
+void Light::Interface::SetRgbValueCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetRgbValueResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetRgbValueResponse*>(_buffer.data());
+ Light::SetTransactionHeaderFor::SetRgbValueResponse(
+ ::fidl::DecodedMessage<SetRgbValueResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetRgbValueResponse::PrimarySize,
+ SetRgbValueResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetRgbValueResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetRgbValueResponse>(std::move(_buffer)));
+}
+
+void Light::Interface::SetRgbValueCompleterBase::Reply(::fidl::DecodedMessage<SetRgbValueResponse> params) {
+ Light::SetTransactionHeaderFor::SetRgbValueResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Light::SetTransactionHeaderFor::GetNameRequest(const ::fidl::DecodedMessage<Light::GetNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_GetName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Light::SetTransactionHeaderFor::GetNameResponse(const ::fidl::DecodedMessage<Light::GetNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_GetName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Light::SetTransactionHeaderFor::GetCountRequest(const ::fidl::DecodedMessage<Light::GetCountRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_GetCount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Light::SetTransactionHeaderFor::GetCountResponse(const ::fidl::DecodedMessage<Light::GetCountResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_GetCount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Light::SetTransactionHeaderFor::HasCapabilityRequest(const ::fidl::DecodedMessage<Light::HasCapabilityRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_HasCapability_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Light::SetTransactionHeaderFor::HasCapabilityResponse(const ::fidl::DecodedMessage<Light::HasCapabilityResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_HasCapability_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Light::SetTransactionHeaderFor::GetSimpleValueRequest(const ::fidl::DecodedMessage<Light::GetSimpleValueRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_GetSimpleValue_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Light::SetTransactionHeaderFor::GetSimpleValueResponse(const ::fidl::DecodedMessage<Light::GetSimpleValueResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_GetSimpleValue_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Light::SetTransactionHeaderFor::SetSimpleValueRequest(const ::fidl::DecodedMessage<Light::SetSimpleValueRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_SetSimpleValue_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Light::SetTransactionHeaderFor::SetSimpleValueResponse(const ::fidl::DecodedMessage<Light::SetSimpleValueResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_SetSimpleValue_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Light::SetTransactionHeaderFor::GetRgbValueRequest(const ::fidl::DecodedMessage<Light::GetRgbValueRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_GetRgbValue_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Light::SetTransactionHeaderFor::GetRgbValueResponse(const ::fidl::DecodedMessage<Light::GetRgbValueResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_GetRgbValue_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Light::SetTransactionHeaderFor::SetRgbValueRequest(const ::fidl::DecodedMessage<Light::SetRgbValueRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_SetRgbValue_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Light::SetTransactionHeaderFor::SetRgbValueResponse(const ::fidl::DecodedMessage<Light::SetRgbValueResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLight_SetRgbValue_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace light
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-light/gen/llcpp/include/fuchsia/hardware/light/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-light/gen/llcpp/include/fuchsia/hardware/light/llcpp/fidl.h
new file mode 100644
index 0000000..fe5b279
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-light/gen/llcpp/include/fuchsia/hardware/light/llcpp/fidl.h
@@ -0,0 +1,959 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace light {
+
+struct Rgb;
+enum class Capability : uint32_t {
+ BRIGHTNESS = 0u,
+ RGB = 1u,
+};
+
+
+class Light;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_RgbTable;
+
+struct Rgb {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_RgbTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 3;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t red = {};
+
+ uint8_t green = {};
+
+ uint8_t blue = {};
+};
+
+constexpr uint8_t LIGHT_NAME_LEN = 32u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetCountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetCountResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightHasCapabilityRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightHasCapabilityResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetSimpleValueRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetSimpleValueResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightSetSimpleValueRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightSetSimpleValueResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetRgbValueRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightGetRgbValueResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightSetRgbValueRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_light_LightSetRgbValueResponseTable;
+
+class Light final {
+ Light() = delete;
+ public:
+
+ 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_light_LightGetNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ 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;
+ };
+ struct GetNameRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightGetNameRequestTable;
+ 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 = GetNameResponse;
+ };
+
+ struct GetCountResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightGetCountResponseTable;
+ 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 GetCountRequest = ::fidl::AnyZeroArgMessage;
+
+ struct HasCapabilityResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ bool has;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightHasCapabilityResponseTable;
+ 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 HasCapabilityRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t index;
+ ::llcpp::fuchsia::hardware::light::Capability capability;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightHasCapabilityRequestTable;
+ 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 = HasCapabilityResponse;
+ };
+
+ struct GetSimpleValueResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint8_t value;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightGetSimpleValueResponseTable;
+ 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 GetSimpleValueRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightGetSimpleValueRequestTable;
+ 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 = GetSimpleValueResponse;
+ };
+
+ struct SetSimpleValueResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightSetSimpleValueResponseTable;
+ 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 SetSimpleValueRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t index;
+ uint8_t value;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightSetSimpleValueRequestTable;
+ 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 = SetSimpleValueResponse;
+ };
+
+ struct GetRgbValueResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::hardware::light::Rgb value;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightGetRgbValueResponseTable;
+ 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 GetRgbValueRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightGetRgbValueRequestTable;
+ 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 = GetRgbValueResponse;
+ };
+
+ struct SetRgbValueResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightSetRgbValueResponseTable;
+ 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 SetRgbValueRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t index;
+ ::llcpp::fuchsia::hardware::light::Rgb value;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_light_LightSetRgbValueRequestTable;
+ 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 = SetRgbValueResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ 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, uint32_t index);
+ ~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 GetCount_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetCount_Impl(::zx::unowned_channel _client_end);
+ ~GetCount_Impl() = default;
+ GetCount_Impl(GetCount_Impl&& other) = default;
+ GetCount_Impl& operator=(GetCount_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 HasCapability_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ HasCapability_Impl(::zx::unowned_channel _client_end, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability);
+ ~HasCapability_Impl() = default;
+ HasCapability_Impl(HasCapability_Impl&& other) = default;
+ HasCapability_Impl& operator=(HasCapability_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 GetSimpleValue_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSimpleValue_Impl(::zx::unowned_channel _client_end, uint32_t index);
+ ~GetSimpleValue_Impl() = default;
+ GetSimpleValue_Impl(GetSimpleValue_Impl&& other) = default;
+ GetSimpleValue_Impl& operator=(GetSimpleValue_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 SetSimpleValue_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetSimpleValue_Impl(::zx::unowned_channel _client_end, uint32_t index, uint8_t value);
+ ~SetSimpleValue_Impl() = default;
+ SetSimpleValue_Impl(SetSimpleValue_Impl&& other) = default;
+ SetSimpleValue_Impl& operator=(SetSimpleValue_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 GetRgbValue_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetRgbValue_Impl(::zx::unowned_channel _client_end, uint32_t index);
+ ~GetRgbValue_Impl() = default;
+ GetRgbValue_Impl(GetRgbValue_Impl&& other) = default;
+ GetRgbValue_Impl& operator=(GetRgbValue_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 SetRgbValue_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetRgbValue_Impl(::zx::unowned_channel _client_end, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value);
+ ~SetRgbValue_Impl() = default;
+ SetRgbValue_Impl(SetRgbValue_Impl&& other) = default;
+ SetRgbValue_Impl& operator=(SetRgbValue_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 GetName = GetName_Impl<GetNameResponse>;
+ using GetCount = GetCount_Impl<GetCountResponse>;
+ using HasCapability = HasCapability_Impl<HasCapabilityResponse>;
+ using GetSimpleValue = GetSimpleValue_Impl<GetSimpleValueResponse>;
+ using SetSimpleValue = SetSimpleValue_Impl<SetSimpleValueResponse>;
+ using GetRgbValue = GetRgbValue_Impl<GetRgbValueResponse>;
+ using SetRgbValue = SetRgbValue_Impl<SetRgbValueResponse>;
+ };
+
+ // 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 GetName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::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 GetCount_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetCount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetCount_Impl() = default;
+ GetCount_Impl(GetCount_Impl&& other) = default;
+ GetCount_Impl& operator=(GetCount_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 HasCapability_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ HasCapability_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability, ::fidl::BytePart _response_buffer);
+ ~HasCapability_Impl() = default;
+ HasCapability_Impl(HasCapability_Impl&& other) = default;
+ HasCapability_Impl& operator=(HasCapability_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 GetSimpleValue_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSimpleValue_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer);
+ ~GetSimpleValue_Impl() = default;
+ GetSimpleValue_Impl(GetSimpleValue_Impl&& other) = default;
+ GetSimpleValue_Impl& operator=(GetSimpleValue_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 SetSimpleValue_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetSimpleValue_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, uint8_t value, ::fidl::BytePart _response_buffer);
+ ~SetSimpleValue_Impl() = default;
+ SetSimpleValue_Impl(SetSimpleValue_Impl&& other) = default;
+ SetSimpleValue_Impl& operator=(SetSimpleValue_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 GetRgbValue_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetRgbValue_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer);
+ ~GetRgbValue_Impl() = default;
+ GetRgbValue_Impl(GetRgbValue_Impl&& other) = default;
+ GetRgbValue_Impl& operator=(GetRgbValue_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 SetRgbValue_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetRgbValue_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value, ::fidl::BytePart _response_buffer);
+ ~SetRgbValue_Impl() = default;
+ SetRgbValue_Impl(SetRgbValue_Impl&& other) = default;
+ SetRgbValue_Impl& operator=(SetRgbValue_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 GetName = GetName_Impl<GetNameResponse>;
+ using GetCount = GetCount_Impl<GetCountResponse>;
+ using HasCapability = HasCapability_Impl<HasCapabilityResponse>;
+ using GetSimpleValue = GetSimpleValue_Impl<GetSimpleValueResponse>;
+ using SetSimpleValue = SetSimpleValue_Impl<SetSimpleValueResponse>;
+ using GetRgbValue = GetRgbValue_Impl<GetRgbValueResponse>;
+ using SetRgbValue = SetRgbValue_Impl<SetRgbValueResponse>;
+ };
+
+ 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 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetName GetName(uint32_t index);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetName GetName(::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetCount GetCount();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetCount GetCount(::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::HasCapability HasCapability(uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::HasCapability HasCapability(::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetSimpleValue GetSimpleValue(uint32_t index);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSimpleValue GetSimpleValue(::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetSimpleValue SetSimpleValue(uint32_t index, uint8_t value);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetSimpleValue SetSimpleValue(::fidl::BytePart _request_buffer, uint32_t index, uint8_t value, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetRgbValue GetRgbValue(uint32_t index);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetRgbValue GetRgbValue(::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetRgbValue SetRgbValue(uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetRgbValue SetRgbValue(::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value, ::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 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetName GetName(::zx::unowned_channel _client_end, uint32_t index);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetName GetName(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetCount GetCount(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetCount GetCount(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::HasCapability HasCapability(::zx::unowned_channel _client_end, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::HasCapability HasCapability(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetSimpleValue GetSimpleValue(::zx::unowned_channel _client_end, uint32_t index);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSimpleValue GetSimpleValue(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetSimpleValue SetSimpleValue(::zx::unowned_channel _client_end, uint32_t index, uint8_t value);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetSimpleValue SetSimpleValue(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, uint8_t value, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetRgbValue GetRgbValue(::zx::unowned_channel _client_end, uint32_t index);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetRgbValue GetRgbValue(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetRgbValue SetRgbValue(::zx::unowned_channel _client_end, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetRgbValue SetRgbValue(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value, ::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<GetNameResponse> GetName(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetNameRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetCountResponse> GetCount(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<HasCapabilityResponse> HasCapability(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<HasCapabilityRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetSimpleValueResponse> GetSimpleValue(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSimpleValueRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<SetSimpleValueResponse> SetSimpleValue(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSimpleValueRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetRgbValueResponse> GetRgbValue(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetRgbValueRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<SetRgbValueResponse> SetRgbValue(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetRgbValueRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Light;
+ using _Base = ::fidl::CompleterBase;
+
+ 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(uint32_t index, GetNameCompleter::Sync _completer) = 0;
+
+ class GetCountCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t count);
+ void Reply(::fidl::BytePart _buffer, uint32_t count);
+ void Reply(::fidl::DecodedMessage<GetCountResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCountCompleter = ::fidl::Completer<GetCountCompleterBase>;
+
+ virtual void GetCount(GetCountCompleter::Sync _completer) = 0;
+
+ class HasCapabilityCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, bool has);
+ void Reply(::fidl::BytePart _buffer, int32_t status, bool has);
+ void Reply(::fidl::DecodedMessage<HasCapabilityResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using HasCapabilityCompleter = ::fidl::Completer<HasCapabilityCompleterBase>;
+
+ virtual void HasCapability(uint32_t index, ::llcpp::fuchsia::hardware::light::Capability capability, HasCapabilityCompleter::Sync _completer) = 0;
+
+ class GetSimpleValueCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint8_t value);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint8_t value);
+ void Reply(::fidl::DecodedMessage<GetSimpleValueResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSimpleValueCompleter = ::fidl::Completer<GetSimpleValueCompleterBase>;
+
+ virtual void GetSimpleValue(uint32_t index, GetSimpleValueCompleter::Sync _completer) = 0;
+
+ class SetSimpleValueCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetSimpleValueResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetSimpleValueCompleter = ::fidl::Completer<SetSimpleValueCompleterBase>;
+
+ virtual void SetSimpleValue(uint32_t index, uint8_t value, SetSimpleValueCompleter::Sync _completer) = 0;
+
+ class GetRgbValueCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::hardware::light::Rgb value);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::light::Rgb value);
+ void Reply(::fidl::DecodedMessage<GetRgbValueResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetRgbValueCompleter = ::fidl::Completer<GetRgbValueCompleterBase>;
+
+ virtual void GetRgbValue(uint32_t index, GetRgbValueCompleter::Sync _completer) = 0;
+
+ class SetRgbValueCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetRgbValueResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetRgbValueCompleter = ::fidl::Completer<SetRgbValueCompleterBase>;
+
+ virtual void SetRgbValue(uint32_t index, ::llcpp::fuchsia::hardware::light::Rgb value, SetRgbValueCompleter::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 GetNameRequest(const ::fidl::DecodedMessage<Light::GetNameRequest>& _msg);
+ static void GetNameResponse(const ::fidl::DecodedMessage<Light::GetNameResponse>& _msg);
+ static void GetCountRequest(const ::fidl::DecodedMessage<Light::GetCountRequest>& _msg);
+ static void GetCountResponse(const ::fidl::DecodedMessage<Light::GetCountResponse>& _msg);
+ static void HasCapabilityRequest(const ::fidl::DecodedMessage<Light::HasCapabilityRequest>& _msg);
+ static void HasCapabilityResponse(const ::fidl::DecodedMessage<Light::HasCapabilityResponse>& _msg);
+ static void GetSimpleValueRequest(const ::fidl::DecodedMessage<Light::GetSimpleValueRequest>& _msg);
+ static void GetSimpleValueResponse(const ::fidl::DecodedMessage<Light::GetSimpleValueResponse>& _msg);
+ static void SetSimpleValueRequest(const ::fidl::DecodedMessage<Light::SetSimpleValueRequest>& _msg);
+ static void SetSimpleValueResponse(const ::fidl::DecodedMessage<Light::SetSimpleValueResponse>& _msg);
+ static void GetRgbValueRequest(const ::fidl::DecodedMessage<Light::GetRgbValueRequest>& _msg);
+ static void GetRgbValueResponse(const ::fidl::DecodedMessage<Light::GetRgbValueResponse>& _msg);
+ static void SetRgbValueRequest(const ::fidl::DecodedMessage<Light::SetRgbValueRequest>& _msg);
+ static void SetRgbValueResponse(const ::fidl::DecodedMessage<Light::SetRgbValueResponse>& _msg);
+ };
+};
+
+} // namespace light
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Rgb> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::light::Rgb>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Rgb, red) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Rgb, green) == 1);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Rgb, blue) == 2);
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Rgb) == ::llcpp::fuchsia::hardware::light::Rgb::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::GetNameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::GetNameRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::GetNameRequest)
+ == ::llcpp::fuchsia::hardware::light::Light::GetNameRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetNameRequest, index) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::GetNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::GetNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::GetNameResponse)
+ == ::llcpp::fuchsia::hardware::light::Light::GetNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetNameResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetNameResponse, name) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::GetCountResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::GetCountResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::GetCountResponse)
+ == ::llcpp::fuchsia::hardware::light::Light::GetCountResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetCountResponse, count) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::HasCapabilityRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::HasCapabilityRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::HasCapabilityRequest)
+ == ::llcpp::fuchsia::hardware::light::Light::HasCapabilityRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::HasCapabilityRequest, index) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::HasCapabilityRequest, capability) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::HasCapabilityResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::HasCapabilityResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::HasCapabilityResponse)
+ == ::llcpp::fuchsia::hardware::light::Light::HasCapabilityResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::HasCapabilityResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::HasCapabilityResponse, has) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::GetSimpleValueRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::GetSimpleValueRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::GetSimpleValueRequest)
+ == ::llcpp::fuchsia::hardware::light::Light::GetSimpleValueRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetSimpleValueRequest, index) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::GetSimpleValueResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::GetSimpleValueResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::GetSimpleValueResponse)
+ == ::llcpp::fuchsia::hardware::light::Light::GetSimpleValueResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetSimpleValueResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetSimpleValueResponse, value) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::SetSimpleValueRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::SetSimpleValueRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::SetSimpleValueRequest)
+ == ::llcpp::fuchsia::hardware::light::Light::SetSimpleValueRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::SetSimpleValueRequest, index) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::SetSimpleValueRequest, value) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::SetSimpleValueResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::SetSimpleValueResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::SetSimpleValueResponse)
+ == ::llcpp::fuchsia::hardware::light::Light::SetSimpleValueResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::SetSimpleValueResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::GetRgbValueRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::GetRgbValueRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::GetRgbValueRequest)
+ == ::llcpp::fuchsia::hardware::light::Light::GetRgbValueRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetRgbValueRequest, index) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::GetRgbValueResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::GetRgbValueResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::GetRgbValueResponse)
+ == ::llcpp::fuchsia::hardware::light::Light::GetRgbValueResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetRgbValueResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::GetRgbValueResponse, value) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::SetRgbValueRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::SetRgbValueRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::SetRgbValueRequest)
+ == ::llcpp::fuchsia::hardware::light::Light::SetRgbValueRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::SetRgbValueRequest, index) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::SetRgbValueRequest, value) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::light::Light::SetRgbValueResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::light::Light::SetRgbValueResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::light::Light::SetRgbValueResponse)
+ == ::llcpp::fuchsia::hardware::light::Light::SetRgbValueResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::light::Light::SetRgbValueResponse, status) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-midi/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-midi/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..238de84
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-midi/gen/llcpp/fidl.cc
@@ -0,0 +1,174 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/midi/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace midi {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetInfo_Ordinal = 0x7eddfe3c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetInfo_GenOrdinal = 0x67d496c0a087b7dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_midi_DeviceGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_midi_DeviceGetInfoResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetInfo_Impl<Device::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetInfo Device::SyncClient::GetInfo() {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetInfo Device::Call::GetInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInfo(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetInfo_Impl<Device::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetInfo Device::SyncClient::GetInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetInfo Device::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetInfoResponse> Device::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInfoRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetInfo_Ordinal:
+ case kDevice_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInfo(
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetInfoCompleterBase::Reply(::llcpp::fuchsia::hardware::midi::Info info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetInfoResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetInfoResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::midi::Info info) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetInfoResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ _buffer.set_actual(sizeof(GetInfoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetInfoResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ Device::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<Device::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<Device::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace midi
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-midi/gen/llcpp/include/fuchsia/hardware/midi/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-midi/gen/llcpp/include/fuchsia/hardware/midi/llcpp/fidl.h
new file mode 100644
index 0000000..788e292
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-midi/gen/llcpp/include/fuchsia/hardware/midi/llcpp/fidl.h
@@ -0,0 +1,246 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace midi {
+
+struct Info;
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_midi_InfoTable;
+
+// Describes what type of MIDI device an implementation of Device represents
+struct Info {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_midi_InfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 2;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Whether or not this device is a MIDI sink
+ bool is_sink = {};
+
+ // Whether or not this device is a MIDI source
+ bool is_source = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_midi_DeviceGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_midi_DeviceGetInfoResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::midi::Info info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_midi_DeviceGetInfoResponseTable;
+ 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 GetInfoRequest = ::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*;
+ };
+
+ public:
+ using GetInfo = GetInfo_Impl<GetInfoResponse>;
+ };
+
+ // 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*;
+ };
+
+ public:
+ using GetInfo = GetInfo_Impl<GetInfoResponse>;
+ };
+
+ 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_; }
+
+ // Get information about the type of MIDI device
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetInfo GetInfo();
+
+ // Get information about the type of MIDI device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetInfo GetInfo(::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:
+
+ // Get information about the type of MIDI device
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end);
+
+ // Get information about the type of MIDI device
+ // 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);
+
+ };
+
+ // 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:
+
+ // Get information about the type of MIDI device
+ static ::fidl::DecodeResult<GetInfoResponse> GetInfo(::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 = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetInfoCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::midi::Info info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::midi::Info info);
+ void Reply(::fidl::DecodedMessage<GetInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetInfoCompleter = ::fidl::Completer<GetInfoCompleterBase>;
+
+ virtual void GetInfo(GetInfoCompleter::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<Device::GetInfoRequest>& _msg);
+ static void GetInfoResponse(const ::fidl::DecodedMessage<Device::GetInfoResponse>& _msg);
+ };
+};
+
+} // namespace midi
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::midi::Info> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::midi::Info>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::midi::Info, is_sink) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::midi::Info, is_source) == 1);
+static_assert(sizeof(::llcpp::fuchsia::hardware::midi::Info) == ::llcpp::fuchsia::hardware::midi::Info::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::midi::Device::GetInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::midi::Device::GetInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::midi::Device::GetInfoResponse)
+ == ::llcpp::fuchsia::hardware::midi::Device::GetInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::midi::Device::GetInfoResponse, info) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-network/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-network/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..f4b7dbb
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-network/gen/llcpp/fidl.cc
@@ -0,0 +1,1695 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/network/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace network {
+
+::llcpp::fuchsia::hardware::network::Status::Builder Status::Build() {
+ return Status::Builder();
+}
+
+auto ::llcpp::fuchsia::hardware::network::Status::Builder::set_flags(::llcpp::fuchsia::hardware::network::StatusFlags* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::hardware::network::Status::Builder::set_mtu(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kSession_SetPaused_Ordinal = 0x236b6bda00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSession_SetPaused_GenOrdinal = 0x463e604fa765a658lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionSetPausedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionSetPausedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSession_Close_Ordinal = 0x609d569d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSession_Close_GenOrdinal = 0x393d5070394a92f6lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionCloseResponseTable;
+
+} // namespace
+
+Session::ResultOf::SetPaused_Impl::SetPaused_Impl(::zx::unowned_channel _client_end, bool paused) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetPausedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetPausedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetPausedRequest*>(_write_bytes);
+ _request.paused = std::move(paused);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetPausedRequest));
+ ::fidl::DecodedMessage<SetPausedRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Session::InPlace::SetPaused(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Session::ResultOf::SetPaused Session::SyncClient::SetPaused(bool paused) {
+ return ResultOf::SetPaused(::zx::unowned_channel(this->channel_), std::move(paused));
+}
+
+Session::ResultOf::SetPaused Session::Call::SetPaused(::zx::unowned_channel _client_end, bool paused) {
+ return ResultOf::SetPaused(std::move(_client_end), std::move(paused));
+}
+
+
+Session::UnownedResultOf::SetPaused_Impl::SetPaused_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool paused) {
+ if (_request_buffer.capacity() < SetPausedRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetPausedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetPausedRequest*>(_request_buffer.data());
+ _request.paused = std::move(paused);
+ _request_buffer.set_actual(sizeof(SetPausedRequest));
+ ::fidl::DecodedMessage<SetPausedRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Session::InPlace::SetPaused(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Session::UnownedResultOf::SetPaused Session::SyncClient::SetPaused(::fidl::BytePart _request_buffer, bool paused) {
+ return UnownedResultOf::SetPaused(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(paused));
+}
+
+Session::UnownedResultOf::SetPaused Session::Call::SetPaused(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool paused) {
+ return UnownedResultOf::SetPaused(std::move(_client_end), std::move(_request_buffer), std::move(paused));
+}
+
+::fidl::internal::StatusAndError Session::InPlace::SetPaused(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPausedRequest> params) {
+ Session::SetTransactionHeaderFor::SetPausedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Session::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Session::InPlace::Close(std::move(_client_end)));
+}
+
+Session::ResultOf::Close Session::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Session::ResultOf::Close Session::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Session::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Session::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Session::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kSession_SetPaused_Ordinal:
+ case kSession_SetPaused_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetPausedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetPaused(std::move(message->paused),
+ Interface::SetPausedCompleter::Sync(txn));
+ return true;
+ }
+ case kSession_Close_Ordinal:
+ case kSession_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Session::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void Session::SetTransactionHeaderFor::SetPausedRequest(const ::fidl::DecodedMessage<Session::SetPausedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSession_SetPaused_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Session::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Session::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSession_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDeviceInstance_GetDevice_Ordinal = 0x8c0818e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceInstance_GetDevice_GenOrdinal = 0x775270585575cef7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceInstanceGetDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceInstanceGetDeviceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDeviceInstance_GetMacAddressing_Ordinal = 0x43ba144700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceInstance_GetMacAddressing_GenOrdinal = 0x545e6ef5d5737c62lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceInstanceGetMacAddressingRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceInstanceGetMacAddressingResponseTable;
+
+} // namespace
+
+DeviceInstance::ResultOf::GetDevice_Impl::GetDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel device) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDeviceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetDeviceRequest*>(_write_bytes);
+ _request.device = std::move(device);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceRequest));
+ ::fidl::DecodedMessage<GetDeviceRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DeviceInstance::InPlace::GetDevice(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceInstance::ResultOf::GetDevice DeviceInstance::SyncClient::GetDevice(::zx::channel device) {
+ return ResultOf::GetDevice(::zx::unowned_channel(this->channel_), std::move(device));
+}
+
+DeviceInstance::ResultOf::GetDevice DeviceInstance::Call::GetDevice(::zx::unowned_channel _client_end, ::zx::channel device) {
+ return ResultOf::GetDevice(std::move(_client_end), std::move(device));
+}
+
+
+DeviceInstance::UnownedResultOf::GetDevice_Impl::GetDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device) {
+ if (_request_buffer.capacity() < GetDeviceRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetDeviceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetDeviceRequest*>(_request_buffer.data());
+ _request.device = std::move(device);
+ _request_buffer.set_actual(sizeof(GetDeviceRequest));
+ ::fidl::DecodedMessage<GetDeviceRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DeviceInstance::InPlace::GetDevice(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceInstance::UnownedResultOf::GetDevice DeviceInstance::SyncClient::GetDevice(::fidl::BytePart _request_buffer, ::zx::channel device) {
+ return UnownedResultOf::GetDevice(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(device));
+}
+
+DeviceInstance::UnownedResultOf::GetDevice DeviceInstance::Call::GetDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device) {
+ return UnownedResultOf::GetDevice(std::move(_client_end), std::move(_request_buffer), std::move(device));
+}
+
+::fidl::internal::StatusAndError DeviceInstance::InPlace::GetDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetDeviceRequest> params) {
+ DeviceInstance::SetTransactionHeaderFor::GetDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+DeviceInstance::ResultOf::GetMacAddressing_Impl::GetMacAddressing_Impl(::zx::unowned_channel _client_end, ::zx::channel mac) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMacAddressingRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetMacAddressingRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetMacAddressingRequest*>(_write_bytes);
+ _request.mac = std::move(mac);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMacAddressingRequest));
+ ::fidl::DecodedMessage<GetMacAddressingRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DeviceInstance::InPlace::GetMacAddressing(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceInstance::ResultOf::GetMacAddressing DeviceInstance::SyncClient::GetMacAddressing(::zx::channel mac) {
+ return ResultOf::GetMacAddressing(::zx::unowned_channel(this->channel_), std::move(mac));
+}
+
+DeviceInstance::ResultOf::GetMacAddressing DeviceInstance::Call::GetMacAddressing(::zx::unowned_channel _client_end, ::zx::channel mac) {
+ return ResultOf::GetMacAddressing(std::move(_client_end), std::move(mac));
+}
+
+
+DeviceInstance::UnownedResultOf::GetMacAddressing_Impl::GetMacAddressing_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel mac) {
+ if (_request_buffer.capacity() < GetMacAddressingRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetMacAddressingRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetMacAddressingRequest*>(_request_buffer.data());
+ _request.mac = std::move(mac);
+ _request_buffer.set_actual(sizeof(GetMacAddressingRequest));
+ ::fidl::DecodedMessage<GetMacAddressingRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DeviceInstance::InPlace::GetMacAddressing(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceInstance::UnownedResultOf::GetMacAddressing DeviceInstance::SyncClient::GetMacAddressing(::fidl::BytePart _request_buffer, ::zx::channel mac) {
+ return UnownedResultOf::GetMacAddressing(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mac));
+}
+
+DeviceInstance::UnownedResultOf::GetMacAddressing DeviceInstance::Call::GetMacAddressing(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel mac) {
+ return UnownedResultOf::GetMacAddressing(std::move(_client_end), std::move(_request_buffer), std::move(mac));
+}
+
+::fidl::internal::StatusAndError DeviceInstance::InPlace::GetMacAddressing(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMacAddressingRequest> params) {
+ DeviceInstance::SetTransactionHeaderFor::GetMacAddressingRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool DeviceInstance::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDeviceInstance_GetDevice_Ordinal:
+ case kDeviceInstance_GetDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetDevice(std::move(message->device),
+ Interface::GetDeviceCompleter::Sync(txn));
+ return true;
+ }
+ case kDeviceInstance_GetMacAddressing_Ordinal:
+ case kDeviceInstance_GetMacAddressing_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetMacAddressingRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetMacAddressing(std::move(message->mac),
+ Interface::GetMacAddressingCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DeviceInstance::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void DeviceInstance::SetTransactionHeaderFor::GetDeviceRequest(const ::fidl::DecodedMessage<DeviceInstance::GetDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceInstance_GetDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DeviceInstance::SetTransactionHeaderFor::GetMacAddressingRequest(const ::fidl::DecodedMessage<DeviceInstance::GetMacAddressingRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceInstance_GetMacAddressing_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kStatusWatcher_WatchStatus_Ordinal = 0x58a9002800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStatusWatcher_WatchStatus_GenOrdinal = 0x1369a8125c0862b9lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_StatusWatcherWatchStatusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_StatusWatcherWatchStatusResponseTable;
+
+} // namespace
+template <>
+StatusWatcher::ResultOf::WatchStatus_Impl<StatusWatcher::WatchStatusResponse>::WatchStatus_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchStatusRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchStatusRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchStatusRequest));
+ ::fidl::DecodedMessage<WatchStatusRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StatusWatcher::InPlace::WatchStatus(std::move(_client_end), Super::response_buffer()));
+}
+
+StatusWatcher::ResultOf::WatchStatus StatusWatcher::SyncClient::WatchStatus() {
+ return ResultOf::WatchStatus(::zx::unowned_channel(this->channel_));
+}
+
+StatusWatcher::ResultOf::WatchStatus StatusWatcher::Call::WatchStatus(::zx::unowned_channel _client_end) {
+ return ResultOf::WatchStatus(std::move(_client_end));
+}
+
+template <>
+StatusWatcher::UnownedResultOf::WatchStatus_Impl<StatusWatcher::WatchStatusResponse>::WatchStatus_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WatchStatusRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WatchStatusRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WatchStatusRequest));
+ ::fidl::DecodedMessage<WatchStatusRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StatusWatcher::InPlace::WatchStatus(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StatusWatcher::UnownedResultOf::WatchStatus StatusWatcher::SyncClient::WatchStatus(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchStatus(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StatusWatcher::UnownedResultOf::WatchStatus StatusWatcher::Call::WatchStatus(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WatchStatus(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StatusWatcher::WatchStatusResponse> StatusWatcher::InPlace::WatchStatus(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WatchStatusRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WatchStatusRequest> params(std::move(_request_buffer));
+ StatusWatcher::SetTransactionHeaderFor::WatchStatusRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StatusWatcher::WatchStatusResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchStatusRequest, WatchStatusResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StatusWatcher::WatchStatusResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool StatusWatcher::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kStatusWatcher_WatchStatus_Ordinal:
+ case kStatusWatcher_WatchStatus_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchStatusRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WatchStatus(
+ Interface::WatchStatusCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool StatusWatcher::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void StatusWatcher::Interface::WatchStatusCompleterBase::Reply(::llcpp::fuchsia::hardware::network::Status device_status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchStatusResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ WatchStatusResponse _response = {};
+ StatusWatcher::SetTransactionHeaderFor::WatchStatusResponse(
+ ::fidl::DecodedMessage<WatchStatusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchStatusResponse::PrimarySize,
+ WatchStatusResponse::PrimarySize)));
+ _response.device_status = std::move(device_status);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StatusWatcher::Interface::WatchStatusCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::network::Status device_status) {
+ if (_buffer.capacity() < WatchStatusResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WatchStatusResponse _response = {};
+ StatusWatcher::SetTransactionHeaderFor::WatchStatusResponse(
+ ::fidl::DecodedMessage<WatchStatusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchStatusResponse::PrimarySize,
+ WatchStatusResponse::PrimarySize)));
+ _response.device_status = std::move(device_status);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StatusWatcher::Interface::WatchStatusCompleterBase::Reply(::fidl::DecodedMessage<WatchStatusResponse> params) {
+ StatusWatcher::SetTransactionHeaderFor::WatchStatusResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void StatusWatcher::SetTransactionHeaderFor::WatchStatusRequest(const ::fidl::DecodedMessage<StatusWatcher::WatchStatusRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStatusWatcher_WatchStatus_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StatusWatcher::SetTransactionHeaderFor::WatchStatusResponse(const ::fidl::DecodedMessage<StatusWatcher::WatchStatusResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStatusWatcher_WatchStatus_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kMacAddressing_GetUnicastAddress_Ordinal = 0x64e141600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMacAddressing_GetUnicastAddress_GenOrdinal = 0x2c60b82a4ecfaebelu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingGetUnicastAddressRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingGetUnicastAddressResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMacAddressing_SetMode_Ordinal = 0x19eee98100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMacAddressing_SetMode_GenOrdinal = 0x6297b8dbf03c58clu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingSetModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingSetModeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMacAddressing_AddMulticastAddress_Ordinal = 0xb21e0fe00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMacAddressing_AddMulticastAddress_GenOrdinal = 0xf5637ff11cf0c25lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingAddMulticastAddressRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingAddMulticastAddressResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMacAddressing_RemoveMulticastAddress_Ordinal = 0x6e1bba1f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMacAddressing_RemoveMulticastAddress_GenOrdinal = 0x5dddf4e3ba4e2560lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingRemoveMulticastAddressRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingRemoveMulticastAddressResponseTable;
+
+} // namespace
+template <>
+MacAddressing::ResultOf::GetUnicastAddress_Impl<MacAddressing::GetUnicastAddressResponse>::GetUnicastAddress_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetUnicastAddressRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetUnicastAddressRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetUnicastAddressRequest));
+ ::fidl::DecodedMessage<GetUnicastAddressRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MacAddressing::InPlace::GetUnicastAddress(std::move(_client_end), Super::response_buffer()));
+}
+
+MacAddressing::ResultOf::GetUnicastAddress MacAddressing::SyncClient::GetUnicastAddress() {
+ return ResultOf::GetUnicastAddress(::zx::unowned_channel(this->channel_));
+}
+
+MacAddressing::ResultOf::GetUnicastAddress MacAddressing::Call::GetUnicastAddress(::zx::unowned_channel _client_end) {
+ return ResultOf::GetUnicastAddress(std::move(_client_end));
+}
+
+template <>
+MacAddressing::UnownedResultOf::GetUnicastAddress_Impl<MacAddressing::GetUnicastAddressResponse>::GetUnicastAddress_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetUnicastAddressRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetUnicastAddressRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetUnicastAddressRequest));
+ ::fidl::DecodedMessage<GetUnicastAddressRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MacAddressing::InPlace::GetUnicastAddress(std::move(_client_end), std::move(_response_buffer)));
+}
+
+MacAddressing::UnownedResultOf::GetUnicastAddress MacAddressing::SyncClient::GetUnicastAddress(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetUnicastAddress(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+MacAddressing::UnownedResultOf::GetUnicastAddress MacAddressing::Call::GetUnicastAddress(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetUnicastAddress(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MacAddressing::GetUnicastAddressResponse> MacAddressing::InPlace::GetUnicastAddress(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetUnicastAddressRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetUnicastAddressRequest> params(std::move(_request_buffer));
+ MacAddressing::SetTransactionHeaderFor::GetUnicastAddressRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MacAddressing::GetUnicastAddressResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetUnicastAddressRequest, GetUnicastAddressResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MacAddressing::GetUnicastAddressResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MacAddressing::ResultOf::SetMode_Impl<MacAddressing::SetModeResponse>::SetMode_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::network::MacFilterMode mode) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetModeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetModeRequest*>(_write_bytes);
+ _request.mode = std::move(mode);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetModeRequest));
+ ::fidl::DecodedMessage<SetModeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MacAddressing::InPlace::SetMode(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MacAddressing::ResultOf::SetMode MacAddressing::SyncClient::SetMode(::llcpp::fuchsia::hardware::network::MacFilterMode mode) {
+ return ResultOf::SetMode(::zx::unowned_channel(this->channel_), std::move(mode));
+}
+
+MacAddressing::ResultOf::SetMode MacAddressing::Call::SetMode(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::network::MacFilterMode mode) {
+ return ResultOf::SetMode(std::move(_client_end), std::move(mode));
+}
+
+template <>
+MacAddressing::UnownedResultOf::SetMode_Impl<MacAddressing::SetModeResponse>::SetMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::network::MacFilterMode mode, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetModeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetModeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetModeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetModeRequest*>(_request_buffer.data());
+ _request.mode = std::move(mode);
+ _request_buffer.set_actual(sizeof(SetModeRequest));
+ ::fidl::DecodedMessage<SetModeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MacAddressing::InPlace::SetMode(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MacAddressing::UnownedResultOf::SetMode MacAddressing::SyncClient::SetMode(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::network::MacFilterMode mode, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetMode(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mode), std::move(_response_buffer));
+}
+
+MacAddressing::UnownedResultOf::SetMode MacAddressing::Call::SetMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::network::MacFilterMode mode, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetMode(std::move(_client_end), std::move(_request_buffer), std::move(mode), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MacAddressing::SetModeResponse> MacAddressing::InPlace::SetMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetModeRequest> params, ::fidl::BytePart response_buffer) {
+ MacAddressing::SetTransactionHeaderFor::SetModeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MacAddressing::SetModeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetModeRequest, SetModeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MacAddressing::SetModeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MacAddressing::ResultOf::AddMulticastAddress_Impl<MacAddressing::AddMulticastAddressResponse>::AddMulticastAddress_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::MacAddress address) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddMulticastAddressRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AddMulticastAddressRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AddMulticastAddressRequest*>(_write_bytes);
+ _request.address = std::move(address);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddMulticastAddressRequest));
+ ::fidl::DecodedMessage<AddMulticastAddressRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MacAddressing::InPlace::AddMulticastAddress(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MacAddressing::ResultOf::AddMulticastAddress MacAddressing::SyncClient::AddMulticastAddress(::llcpp::fuchsia::net::MacAddress address) {
+ return ResultOf::AddMulticastAddress(::zx::unowned_channel(this->channel_), std::move(address));
+}
+
+MacAddressing::ResultOf::AddMulticastAddress MacAddressing::Call::AddMulticastAddress(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::MacAddress address) {
+ return ResultOf::AddMulticastAddress(std::move(_client_end), std::move(address));
+}
+
+template <>
+MacAddressing::UnownedResultOf::AddMulticastAddress_Impl<MacAddressing::AddMulticastAddressResponse>::AddMulticastAddress_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AddMulticastAddressRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AddMulticastAddressResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AddMulticastAddressRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AddMulticastAddressRequest*>(_request_buffer.data());
+ _request.address = std::move(address);
+ _request_buffer.set_actual(sizeof(AddMulticastAddressRequest));
+ ::fidl::DecodedMessage<AddMulticastAddressRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MacAddressing::InPlace::AddMulticastAddress(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MacAddressing::UnownedResultOf::AddMulticastAddress MacAddressing::SyncClient::AddMulticastAddress(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddMulticastAddress(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(address), std::move(_response_buffer));
+}
+
+MacAddressing::UnownedResultOf::AddMulticastAddress MacAddressing::Call::AddMulticastAddress(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AddMulticastAddress(std::move(_client_end), std::move(_request_buffer), std::move(address), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MacAddressing::AddMulticastAddressResponse> MacAddressing::InPlace::AddMulticastAddress(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddMulticastAddressRequest> params, ::fidl::BytePart response_buffer) {
+ MacAddressing::SetTransactionHeaderFor::AddMulticastAddressRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MacAddressing::AddMulticastAddressResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AddMulticastAddressRequest, AddMulticastAddressResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MacAddressing::AddMulticastAddressResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+MacAddressing::ResultOf::RemoveMulticastAddress_Impl<MacAddressing::RemoveMulticastAddressResponse>::RemoveMulticastAddress_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::MacAddress address) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveMulticastAddressRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RemoveMulticastAddressRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RemoveMulticastAddressRequest*>(_write_bytes);
+ _request.address = std::move(address);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RemoveMulticastAddressRequest));
+ ::fidl::DecodedMessage<RemoveMulticastAddressRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ MacAddressing::InPlace::RemoveMulticastAddress(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+MacAddressing::ResultOf::RemoveMulticastAddress MacAddressing::SyncClient::RemoveMulticastAddress(::llcpp::fuchsia::net::MacAddress address) {
+ return ResultOf::RemoveMulticastAddress(::zx::unowned_channel(this->channel_), std::move(address));
+}
+
+MacAddressing::ResultOf::RemoveMulticastAddress MacAddressing::Call::RemoveMulticastAddress(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::MacAddress address) {
+ return ResultOf::RemoveMulticastAddress(std::move(_client_end), std::move(address));
+}
+
+template <>
+MacAddressing::UnownedResultOf::RemoveMulticastAddress_Impl<MacAddressing::RemoveMulticastAddressResponse>::RemoveMulticastAddress_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RemoveMulticastAddressRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RemoveMulticastAddressResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RemoveMulticastAddressRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RemoveMulticastAddressRequest*>(_request_buffer.data());
+ _request.address = std::move(address);
+ _request_buffer.set_actual(sizeof(RemoveMulticastAddressRequest));
+ ::fidl::DecodedMessage<RemoveMulticastAddressRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ MacAddressing::InPlace::RemoveMulticastAddress(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+MacAddressing::UnownedResultOf::RemoveMulticastAddress MacAddressing::SyncClient::RemoveMulticastAddress(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RemoveMulticastAddress(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(address), std::move(_response_buffer));
+}
+
+MacAddressing::UnownedResultOf::RemoveMulticastAddress MacAddressing::Call::RemoveMulticastAddress(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RemoveMulticastAddress(std::move(_client_end), std::move(_request_buffer), std::move(address), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<MacAddressing::RemoveMulticastAddressResponse> MacAddressing::InPlace::RemoveMulticastAddress(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RemoveMulticastAddressRequest> params, ::fidl::BytePart response_buffer) {
+ MacAddressing::SetTransactionHeaderFor::RemoveMulticastAddressRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MacAddressing::RemoveMulticastAddressResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RemoveMulticastAddressRequest, RemoveMulticastAddressResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<MacAddressing::RemoveMulticastAddressResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool MacAddressing::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kMacAddressing_GetUnicastAddress_Ordinal:
+ case kMacAddressing_GetUnicastAddress_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetUnicastAddressRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetUnicastAddress(
+ Interface::GetUnicastAddressCompleter::Sync(txn));
+ return true;
+ }
+ case kMacAddressing_SetMode_Ordinal:
+ case kMacAddressing_SetMode_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetModeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetMode(std::move(message->mode),
+ Interface::SetModeCompleter::Sync(txn));
+ return true;
+ }
+ case kMacAddressing_AddMulticastAddress_Ordinal:
+ case kMacAddressing_AddMulticastAddress_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddMulticastAddressRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddMulticastAddress(std::move(message->address),
+ Interface::AddMulticastAddressCompleter::Sync(txn));
+ return true;
+ }
+ case kMacAddressing_RemoveMulticastAddress_Ordinal:
+ case kMacAddressing_RemoveMulticastAddress_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RemoveMulticastAddressRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RemoveMulticastAddress(std::move(message->address),
+ Interface::RemoveMulticastAddressCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool MacAddressing::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void MacAddressing::Interface::GetUnicastAddressCompleterBase::Reply(::llcpp::fuchsia::net::MacAddress address) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetUnicastAddressResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetUnicastAddressResponse*>(_write_bytes);
+ MacAddressing::SetTransactionHeaderFor::GetUnicastAddressResponse(
+ ::fidl::DecodedMessage<GetUnicastAddressResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetUnicastAddressResponse::PrimarySize,
+ GetUnicastAddressResponse::PrimarySize)));
+ _response.address = std::move(address);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetUnicastAddressResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetUnicastAddressResponse>(std::move(_response_bytes)));
+}
+
+void MacAddressing::Interface::GetUnicastAddressCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::net::MacAddress address) {
+ if (_buffer.capacity() < GetUnicastAddressResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetUnicastAddressResponse*>(_buffer.data());
+ MacAddressing::SetTransactionHeaderFor::GetUnicastAddressResponse(
+ ::fidl::DecodedMessage<GetUnicastAddressResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetUnicastAddressResponse::PrimarySize,
+ GetUnicastAddressResponse::PrimarySize)));
+ _response.address = std::move(address);
+ _buffer.set_actual(sizeof(GetUnicastAddressResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetUnicastAddressResponse>(std::move(_buffer)));
+}
+
+void MacAddressing::Interface::GetUnicastAddressCompleterBase::Reply(::fidl::DecodedMessage<GetUnicastAddressResponse> params) {
+ MacAddressing::SetTransactionHeaderFor::GetUnicastAddressResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MacAddressing::Interface::SetModeCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetModeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetModeResponse*>(_write_bytes);
+ MacAddressing::SetTransactionHeaderFor::SetModeResponse(
+ ::fidl::DecodedMessage<SetModeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetModeResponse::PrimarySize,
+ SetModeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetModeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetModeResponse>(std::move(_response_bytes)));
+}
+
+void MacAddressing::Interface::SetModeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetModeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetModeResponse*>(_buffer.data());
+ MacAddressing::SetTransactionHeaderFor::SetModeResponse(
+ ::fidl::DecodedMessage<SetModeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetModeResponse::PrimarySize,
+ SetModeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetModeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetModeResponse>(std::move(_buffer)));
+}
+
+void MacAddressing::Interface::SetModeCompleterBase::Reply(::fidl::DecodedMessage<SetModeResponse> params) {
+ MacAddressing::SetTransactionHeaderFor::SetModeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MacAddressing::Interface::AddMulticastAddressCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddMulticastAddressResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<AddMulticastAddressResponse*>(_write_bytes);
+ MacAddressing::SetTransactionHeaderFor::AddMulticastAddressResponse(
+ ::fidl::DecodedMessage<AddMulticastAddressResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddMulticastAddressResponse::PrimarySize,
+ AddMulticastAddressResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AddMulticastAddressResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<AddMulticastAddressResponse>(std::move(_response_bytes)));
+}
+
+void MacAddressing::Interface::AddMulticastAddressCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < AddMulticastAddressResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<AddMulticastAddressResponse*>(_buffer.data());
+ MacAddressing::SetTransactionHeaderFor::AddMulticastAddressResponse(
+ ::fidl::DecodedMessage<AddMulticastAddressResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AddMulticastAddressResponse::PrimarySize,
+ AddMulticastAddressResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(AddMulticastAddressResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<AddMulticastAddressResponse>(std::move(_buffer)));
+}
+
+void MacAddressing::Interface::AddMulticastAddressCompleterBase::Reply(::fidl::DecodedMessage<AddMulticastAddressResponse> params) {
+ MacAddressing::SetTransactionHeaderFor::AddMulticastAddressResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void MacAddressing::Interface::RemoveMulticastAddressCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RemoveMulticastAddressResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RemoveMulticastAddressResponse*>(_write_bytes);
+ MacAddressing::SetTransactionHeaderFor::RemoveMulticastAddressResponse(
+ ::fidl::DecodedMessage<RemoveMulticastAddressResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RemoveMulticastAddressResponse::PrimarySize,
+ RemoveMulticastAddressResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RemoveMulticastAddressResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RemoveMulticastAddressResponse>(std::move(_response_bytes)));
+}
+
+void MacAddressing::Interface::RemoveMulticastAddressCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < RemoveMulticastAddressResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RemoveMulticastAddressResponse*>(_buffer.data());
+ MacAddressing::SetTransactionHeaderFor::RemoveMulticastAddressResponse(
+ ::fidl::DecodedMessage<RemoveMulticastAddressResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RemoveMulticastAddressResponse::PrimarySize,
+ RemoveMulticastAddressResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(RemoveMulticastAddressResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RemoveMulticastAddressResponse>(std::move(_buffer)));
+}
+
+void MacAddressing::Interface::RemoveMulticastAddressCompleterBase::Reply(::fidl::DecodedMessage<RemoveMulticastAddressResponse> params) {
+ MacAddressing::SetTransactionHeaderFor::RemoveMulticastAddressResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void MacAddressing::SetTransactionHeaderFor::GetUnicastAddressRequest(const ::fidl::DecodedMessage<MacAddressing::GetUnicastAddressRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMacAddressing_GetUnicastAddress_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MacAddressing::SetTransactionHeaderFor::GetUnicastAddressResponse(const ::fidl::DecodedMessage<MacAddressing::GetUnicastAddressResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMacAddressing_GetUnicastAddress_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MacAddressing::SetTransactionHeaderFor::SetModeRequest(const ::fidl::DecodedMessage<MacAddressing::SetModeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMacAddressing_SetMode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MacAddressing::SetTransactionHeaderFor::SetModeResponse(const ::fidl::DecodedMessage<MacAddressing::SetModeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMacAddressing_SetMode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MacAddressing::SetTransactionHeaderFor::AddMulticastAddressRequest(const ::fidl::DecodedMessage<MacAddressing::AddMulticastAddressRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMacAddressing_AddMulticastAddress_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MacAddressing::SetTransactionHeaderFor::AddMulticastAddressResponse(const ::fidl::DecodedMessage<MacAddressing::AddMulticastAddressResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMacAddressing_AddMulticastAddress_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void MacAddressing::SetTransactionHeaderFor::RemoveMulticastAddressRequest(const ::fidl::DecodedMessage<MacAddressing::RemoveMulticastAddressRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMacAddressing_RemoveMulticastAddress_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void MacAddressing::SetTransactionHeaderFor::RemoveMulticastAddressResponse(const ::fidl::DecodedMessage<MacAddressing::RemoveMulticastAddressResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMacAddressing_RemoveMulticastAddress_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::hardware::network::Device_OpenSession_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Device_OpenSession_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Device_OpenSession_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Device_OpenSession_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetInfo_Ordinal = 0x758cc71900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetInfo_GenOrdinal = 0x3c500ca9341e8f56lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStatus_Ordinal = 0x6e0b631700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStatus_GenOrdinal = 0x3e15c944b7e06cedlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetStatusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetStatusResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStatusWatcher_Ordinal = 0x253afc7e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStatusWatcher_GenOrdinal = 0x65079698371e1163lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetStatusWatcherRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetStatusWatcherResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_OpenSession_Ordinal = 0x34d4098f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_OpenSession_GenOrdinal = 0x25940b82146dcf67lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceOpenSessionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceOpenSessionResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetInfo_Impl<Device::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetInfo Device::SyncClient::GetInfo() {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetInfo Device::Call::GetInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInfo(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetInfo_Impl<Device::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetInfo Device::SyncClient::GetInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetInfo Device::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetInfoResponse> Device::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInfoRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetStatus_Impl<Device::GetStatusResponse>::GetStatus_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatusRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStatusRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStatusRequest));
+ ::fidl::DecodedMessage<GetStatusRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetStatus(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetStatus Device::SyncClient::GetStatus() {
+ return ResultOf::GetStatus(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetStatus Device::Call::GetStatus(::zx::unowned_channel _client_end) {
+ return ResultOf::GetStatus(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetStatus_Impl<Device::GetStatusResponse>::GetStatus_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetStatusRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetStatusRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetStatusRequest));
+ ::fidl::DecodedMessage<GetStatusRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetStatus(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetStatus Device::SyncClient::GetStatus(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStatus(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetStatus Device::Call::GetStatus(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStatus(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetStatusResponse> Device::InPlace::GetStatus(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetStatusRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetStatusRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetStatusRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStatusResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStatusRequest, GetStatusResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStatusResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Device::ResultOf::GetStatusWatcher_Impl::GetStatusWatcher_Impl(::zx::unowned_channel _client_end, ::zx::channel watcher, uint32_t buffer) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatusWatcherRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStatusWatcherRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStatusWatcherRequest*>(_write_bytes);
+ _request.watcher = std::move(watcher);
+ _request.buffer = std::move(buffer);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStatusWatcherRequest));
+ ::fidl::DecodedMessage<GetStatusWatcherRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Device::InPlace::GetStatusWatcher(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::ResultOf::GetStatusWatcher Device::SyncClient::GetStatusWatcher(::zx::channel watcher, uint32_t buffer) {
+ return ResultOf::GetStatusWatcher(::zx::unowned_channel(this->channel_), std::move(watcher), std::move(buffer));
+}
+
+Device::ResultOf::GetStatusWatcher Device::Call::GetStatusWatcher(::zx::unowned_channel _client_end, ::zx::channel watcher, uint32_t buffer) {
+ return ResultOf::GetStatusWatcher(std::move(_client_end), std::move(watcher), std::move(buffer));
+}
+
+
+Device::UnownedResultOf::GetStatusWatcher_Impl::GetStatusWatcher_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel watcher, uint32_t buffer) {
+ if (_request_buffer.capacity() < GetStatusWatcherRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetStatusWatcherRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStatusWatcherRequest*>(_request_buffer.data());
+ _request.watcher = std::move(watcher);
+ _request.buffer = std::move(buffer);
+ _request_buffer.set_actual(sizeof(GetStatusWatcherRequest));
+ ::fidl::DecodedMessage<GetStatusWatcherRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Device::InPlace::GetStatusWatcher(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::UnownedResultOf::GetStatusWatcher Device::SyncClient::GetStatusWatcher(::fidl::BytePart _request_buffer, ::zx::channel watcher, uint32_t buffer) {
+ return UnownedResultOf::GetStatusWatcher(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(watcher), std::move(buffer));
+}
+
+Device::UnownedResultOf::GetStatusWatcher Device::Call::GetStatusWatcher(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel watcher, uint32_t buffer) {
+ return UnownedResultOf::GetStatusWatcher(std::move(_client_end), std::move(_request_buffer), std::move(watcher), std::move(buffer));
+}
+
+::fidl::internal::StatusAndError Device::InPlace::GetStatusWatcher(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStatusWatcherRequest> params) {
+ Device::SetTransactionHeaderFor::GetStatusWatcherRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Device::ResultOf::OpenSession_Impl<Device::OpenSessionResponse>::OpenSession_Impl(::zx::unowned_channel _client_end, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenSessionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ OpenSessionRequest _request = {};
+ _request.session_name = std::move(session_name);
+ _request.session_info = std::move(session_info);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenSessionRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::OpenSession(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::OpenSession Device::SyncClient::OpenSession(::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info) {
+ return ResultOf::OpenSession(::zx::unowned_channel(this->channel_), std::move(session_name), std::move(session_info));
+}
+
+Device::ResultOf::OpenSession Device::Call::OpenSession(::zx::unowned_channel _client_end, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info) {
+ return ResultOf::OpenSession(std::move(_client_end), std::move(session_name), std::move(session_info));
+}
+
+template <>
+Device::UnownedResultOf::OpenSession_Impl<Device::OpenSessionResponse>::OpenSession_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < OpenSessionRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<OpenSessionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ OpenSessionRequest _request = {};
+ _request.session_name = std::move(session_name);
+ _request.session_info = std::move(session_info);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenSessionRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::OpenSession(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::OpenSession Device::SyncClient::OpenSession(::fidl::BytePart _request_buffer, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenSession(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(session_name), std::move(session_info), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::OpenSession Device::Call::OpenSession(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenSession(std::move(_client_end), std::move(_request_buffer), std::move(session_name), std::move(session_info), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::OpenSessionResponse> Device::InPlace::OpenSession(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenSessionRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::OpenSessionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::OpenSessionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<OpenSessionRequest, OpenSessionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::OpenSessionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetInfo_Ordinal:
+ case kDevice_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInfo(
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetStatus_Ordinal:
+ case kDevice_GetStatus_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStatusRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetStatus(
+ Interface::GetStatusCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetStatusWatcher_Ordinal:
+ case kDevice_GetStatusWatcher_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStatusWatcherRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetStatusWatcher(std::move(message->watcher), std::move(message->buffer),
+ Interface::GetStatusWatcherCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_OpenSession_Ordinal:
+ case kDevice_OpenSession_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenSessionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OpenSession(std::move(message->session_name), std::move(message->session_info),
+ Interface::OpenSessionCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetInfoCompleterBase::Reply(::llcpp::fuchsia::hardware::network::Info info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::network::Info info) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ Device::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetStatusCompleterBase::Reply(::llcpp::fuchsia::hardware::network::Status device_status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStatusResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetStatusResponse _response = {};
+ Device::SetTransactionHeaderFor::GetStatusResponse(
+ ::fidl::DecodedMessage<GetStatusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatusResponse::PrimarySize,
+ GetStatusResponse::PrimarySize)));
+ _response.device_status = std::move(device_status);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetStatusCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::network::Status device_status) {
+ if (_buffer.capacity() < GetStatusResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetStatusResponse _response = {};
+ Device::SetTransactionHeaderFor::GetStatusResponse(
+ ::fidl::DecodedMessage<GetStatusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStatusResponse::PrimarySize,
+ GetStatusResponse::PrimarySize)));
+ _response.device_status = std::move(device_status);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetStatusCompleterBase::Reply(::fidl::DecodedMessage<GetStatusResponse> params) {
+ Device::SetTransactionHeaderFor::GetStatusResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::OpenSessionCompleterBase::Reply(::llcpp::fuchsia::hardware::network::Device_OpenSession_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenSessionResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OpenSessionResponse _response = {};
+ Device::SetTransactionHeaderFor::OpenSessionResponse(
+ ::fidl::DecodedMessage<OpenSessionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenSessionResponse::PrimarySize,
+ OpenSessionResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::OpenSessionCompleterBase::ReplySuccess(::zx::channel session, ::llcpp::fuchsia::hardware::network::Fifos fifos) {
+ Device_OpenSession_Response response;
+ response.session = std::move(session);
+ response.fifos = std::move(fifos);
+
+ Reply(Device_OpenSession_Result::WithResponse(&response));
+}
+void Device::Interface::OpenSessionCompleterBase::ReplyError(int32_t error) {
+ Reply(Device_OpenSession_Result::WithErr(&error));
+}
+
+void Device::Interface::OpenSessionCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::network::Device_OpenSession_Result result) {
+ if (_buffer.capacity() < OpenSessionResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ OpenSessionResponse _response = {};
+ Device::SetTransactionHeaderFor::OpenSessionResponse(
+ ::fidl::DecodedMessage<OpenSessionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenSessionResponse::PrimarySize,
+ OpenSessionResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::OpenSessionCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::channel session, ::llcpp::fuchsia::hardware::network::Fifos fifos) {
+ Device_OpenSession_Response response;
+ response.session = std::move(session);
+ response.fifos = std::move(fifos);
+
+ Reply(std::move(_buffer), Device_OpenSession_Result::WithResponse(&response));
+}
+
+void Device::Interface::OpenSessionCompleterBase::Reply(::fidl::DecodedMessage<OpenSessionResponse> params) {
+ Device::SetTransactionHeaderFor::OpenSessionResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<Device::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<Device::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetStatusRequest(const ::fidl::DecodedMessage<Device::GetStatusRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStatus_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetStatusResponse(const ::fidl::DecodedMessage<Device::GetStatusResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStatus_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetStatusWatcherRequest(const ::fidl::DecodedMessage<Device::GetStatusWatcherRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStatusWatcher_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::OpenSessionRequest(const ::fidl::DecodedMessage<Device::OpenSessionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_OpenSession_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::OpenSessionResponse(const ::fidl::DecodedMessage<Device::OpenSessionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_OpenSession_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace network
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-network/gen/llcpp/include/fuchsia/hardware/network/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-network/gen/llcpp/include/fuchsia/hardware/network/llcpp/fidl.h
new file mode 100644
index 0000000..a83e15f
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-network/gen/llcpp/include/fuchsia/hardware/network/llcpp/fidl.h
@@ -0,0 +1,2908 @@
+// 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/net/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace network {
+
+class TxReturnFlags final {
+public:
+ constexpr TxReturnFlags() : value_(0u) {}
+ explicit constexpr TxReturnFlags(uint32_t value) : value_(value) {}
+ const static TxReturnFlags TX_RET_NOT_SUPPORTED;
+ const static TxReturnFlags TX_RET_OUT_OF_RESOURCES;
+ const static TxReturnFlags TX_RET_NOT_AVAILABLE;
+ const static TxReturnFlags TX_RET_ERROR;
+ const static TxReturnFlags mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const TxReturnFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const TxReturnFlags& other) const { return value_ != other.value_; }
+ constexpr inline TxReturnFlags operator~() const;
+ constexpr inline TxReturnFlags operator|(const TxReturnFlags& other) const;
+ constexpr inline TxReturnFlags operator&(const TxReturnFlags& other) const;
+ constexpr inline TxReturnFlags operator^(const TxReturnFlags& other) const;
+ constexpr inline void operator|=(const TxReturnFlags& other);
+ constexpr inline void operator&=(const TxReturnFlags& other);
+ constexpr inline void operator^=(const TxReturnFlags& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::TX_RET_NOT_SUPPORTED = ::llcpp::fuchsia::hardware::network::TxReturnFlags(1u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::TX_RET_OUT_OF_RESOURCES = ::llcpp::fuchsia::hardware::network::TxReturnFlags(2u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::TX_RET_NOT_AVAILABLE = ::llcpp::fuchsia::hardware::network::TxReturnFlags(4u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::TX_RET_ERROR = ::llcpp::fuchsia::hardware::network::TxReturnFlags(2147483648u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::mask = ::llcpp::fuchsia::hardware::network::TxReturnFlags(2147483655u);
+
+constexpr inline ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::operator~() const {
+ return ::llcpp::fuchsia::hardware::network::TxReturnFlags(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::operator|(
+ const ::llcpp::fuchsia::hardware::network::TxReturnFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::TxReturnFlags(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::operator&(
+ const ::llcpp::fuchsia::hardware::network::TxReturnFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::TxReturnFlags(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::TxReturnFlags TxReturnFlags::operator^(
+ const ::llcpp::fuchsia::hardware::network::TxReturnFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::TxReturnFlags(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void TxReturnFlags::operator|=(
+ const ::llcpp::fuchsia::hardware::network::TxReturnFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void TxReturnFlags::operator&=(
+ const ::llcpp::fuchsia::hardware::network::TxReturnFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void TxReturnFlags::operator^=(
+ const ::llcpp::fuchsia::hardware::network::TxReturnFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+class TxFlags final {
+public:
+ constexpr TxFlags() : value_(0u) {}
+ explicit constexpr TxFlags(uint32_t value) : value_(value) {}
+ const static TxFlags TX_ACCEL_0;
+ const static TxFlags TX_ACCEL_1;
+ const static TxFlags TX_ACCEL_2;
+ const static TxFlags TX_ACCEL_3;
+ const static TxFlags TX_ACCEL_4;
+ const static TxFlags TX_ACCEL_5;
+ const static TxFlags TX_ACCEL_6;
+ const static TxFlags TX_ACCEL_7;
+ const static TxFlags TX_ACCEL_8;
+ const static TxFlags TX_ACCEL_9;
+ const static TxFlags TX_ACCEL_10;
+ const static TxFlags TX_ACCEL_11;
+ const static TxFlags TX_ACCEL_12;
+ const static TxFlags TX_ACCEL_13;
+ const static TxFlags TX_ACCEL_14;
+ const static TxFlags TX_ACCEL_15;
+ const static TxFlags mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const TxFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const TxFlags& other) const { return value_ != other.value_; }
+ constexpr inline TxFlags operator~() const;
+ constexpr inline TxFlags operator|(const TxFlags& other) const;
+ constexpr inline TxFlags operator&(const TxFlags& other) const;
+ constexpr inline TxFlags operator^(const TxFlags& other) const;
+ constexpr inline void operator|=(const TxFlags& other);
+ constexpr inline void operator&=(const TxFlags& other);
+ constexpr inline void operator^=(const TxFlags& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_0 = ::llcpp::fuchsia::hardware::network::TxFlags(1u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_1 = ::llcpp::fuchsia::hardware::network::TxFlags(2u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_2 = ::llcpp::fuchsia::hardware::network::TxFlags(4u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_3 = ::llcpp::fuchsia::hardware::network::TxFlags(8u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_4 = ::llcpp::fuchsia::hardware::network::TxFlags(16u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_5 = ::llcpp::fuchsia::hardware::network::TxFlags(32u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_6 = ::llcpp::fuchsia::hardware::network::TxFlags(64u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_7 = ::llcpp::fuchsia::hardware::network::TxFlags(128u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_8 = ::llcpp::fuchsia::hardware::network::TxFlags(256u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_9 = ::llcpp::fuchsia::hardware::network::TxFlags(512u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_10 = ::llcpp::fuchsia::hardware::network::TxFlags(1024u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_11 = ::llcpp::fuchsia::hardware::network::TxFlags(2048u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_12 = ::llcpp::fuchsia::hardware::network::TxFlags(4096u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_13 = ::llcpp::fuchsia::hardware::network::TxFlags(8192u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_14 = ::llcpp::fuchsia::hardware::network::TxFlags(16384u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::TX_ACCEL_15 = ::llcpp::fuchsia::hardware::network::TxFlags(32768u);
+constexpr const ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::mask = ::llcpp::fuchsia::hardware::network::TxFlags(65535u);
+
+constexpr inline ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::operator~() const {
+ return ::llcpp::fuchsia::hardware::network::TxFlags(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::operator|(
+ const ::llcpp::fuchsia::hardware::network::TxFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::TxFlags(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::operator&(
+ const ::llcpp::fuchsia::hardware::network::TxFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::TxFlags(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::TxFlags TxFlags::operator^(
+ const ::llcpp::fuchsia::hardware::network::TxFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::TxFlags(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void TxFlags::operator|=(
+ const ::llcpp::fuchsia::hardware::network::TxFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void TxFlags::operator&=(
+ const ::llcpp::fuchsia::hardware::network::TxFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void TxFlags::operator^=(
+ const ::llcpp::fuchsia::hardware::network::TxFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+enum class TxAcceleration : uint8_t {
+ COMPUTE_ETHERNET_FCS = 0u,
+ COMPUTE_IPV4_CHECKSUM = 1u,
+ COMPUTE_TCP_CHECKSUM = 2u,
+ COMPUTE_UDP_CHECKSUM = 3u,
+};
+
+
+class StatusFlags final {
+public:
+ constexpr StatusFlags() : value_(0u) {}
+ explicit constexpr StatusFlags(uint32_t value) : value_(value) {}
+ const static StatusFlags ONLINE;
+ const static StatusFlags mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const StatusFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const StatusFlags& other) const { return value_ != other.value_; }
+ constexpr inline StatusFlags operator~() const;
+ constexpr inline StatusFlags operator|(const StatusFlags& other) const;
+ constexpr inline StatusFlags operator&(const StatusFlags& other) const;
+ constexpr inline StatusFlags operator^(const StatusFlags& other) const;
+ constexpr inline void operator|=(const StatusFlags& other);
+ constexpr inline void operator&=(const StatusFlags& other);
+ constexpr inline void operator^=(const StatusFlags& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::hardware::network::StatusFlags StatusFlags::ONLINE = ::llcpp::fuchsia::hardware::network::StatusFlags(1u);
+constexpr const ::llcpp::fuchsia::hardware::network::StatusFlags StatusFlags::mask = ::llcpp::fuchsia::hardware::network::StatusFlags(1u);
+
+constexpr inline ::llcpp::fuchsia::hardware::network::StatusFlags StatusFlags::operator~() const {
+ return ::llcpp::fuchsia::hardware::network::StatusFlags(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::StatusFlags StatusFlags::operator|(
+ const ::llcpp::fuchsia::hardware::network::StatusFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::StatusFlags(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::StatusFlags StatusFlags::operator&(
+ const ::llcpp::fuchsia::hardware::network::StatusFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::StatusFlags(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::StatusFlags StatusFlags::operator^(
+ const ::llcpp::fuchsia::hardware::network::StatusFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::StatusFlags(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void StatusFlags::operator|=(
+ const ::llcpp::fuchsia::hardware::network::StatusFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void StatusFlags::operator&=(
+ const ::llcpp::fuchsia::hardware::network::StatusFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void StatusFlags::operator^=(
+ const ::llcpp::fuchsia::hardware::network::StatusFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+struct Status;
+class Session;
+class DeviceInstance;
+class StatusWatcher;
+class SessionFlags final {
+public:
+ constexpr SessionFlags() : value_(0u) {}
+ explicit constexpr SessionFlags(uint16_t value) : value_(value) {}
+ const static SessionFlags PRIMARY;
+ const static SessionFlags LISTEN_TX;
+ const static SessionFlags REPORT_INVALID_RX;
+ const static SessionFlags mask;
+
+ explicit constexpr inline operator uint16_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const SessionFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const SessionFlags& other) const { return value_ != other.value_; }
+ constexpr inline SessionFlags operator~() const;
+ constexpr inline SessionFlags operator|(const SessionFlags& other) const;
+ constexpr inline SessionFlags operator&(const SessionFlags& other) const;
+ constexpr inline SessionFlags operator^(const SessionFlags& other) const;
+ constexpr inline void operator|=(const SessionFlags& other);
+ constexpr inline void operator&=(const SessionFlags& other);
+ constexpr inline void operator^=(const SessionFlags& other);
+
+private:
+ uint16_t value_;
+};
+constexpr const ::llcpp::fuchsia::hardware::network::SessionFlags SessionFlags::PRIMARY = ::llcpp::fuchsia::hardware::network::SessionFlags(1u);
+constexpr const ::llcpp::fuchsia::hardware::network::SessionFlags SessionFlags::LISTEN_TX = ::llcpp::fuchsia::hardware::network::SessionFlags(2u);
+constexpr const ::llcpp::fuchsia::hardware::network::SessionFlags SessionFlags::REPORT_INVALID_RX = ::llcpp::fuchsia::hardware::network::SessionFlags(4u);
+constexpr const ::llcpp::fuchsia::hardware::network::SessionFlags SessionFlags::mask = ::llcpp::fuchsia::hardware::network::SessionFlags(7u);
+
+constexpr inline ::llcpp::fuchsia::hardware::network::SessionFlags SessionFlags::operator~() const {
+ return ::llcpp::fuchsia::hardware::network::SessionFlags(static_cast<uint16_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::SessionFlags SessionFlags::operator|(
+ const ::llcpp::fuchsia::hardware::network::SessionFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::SessionFlags(static_cast<uint16_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::SessionFlags SessionFlags::operator&(
+ const ::llcpp::fuchsia::hardware::network::SessionFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::SessionFlags(static_cast<uint16_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::SessionFlags SessionFlags::operator^(
+ const ::llcpp::fuchsia::hardware::network::SessionFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::SessionFlags(static_cast<uint16_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void SessionFlags::operator|=(
+ const ::llcpp::fuchsia::hardware::network::SessionFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void SessionFlags::operator&=(
+ const ::llcpp::fuchsia::hardware::network::SessionFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void SessionFlags::operator^=(
+ const ::llcpp::fuchsia::hardware::network::SessionFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+class RxFlags final {
+public:
+ constexpr RxFlags() : value_(0u) {}
+ explicit constexpr RxFlags(uint32_t value) : value_(value) {}
+ const static RxFlags RX_ACCEL_0;
+ const static RxFlags RX_ACCEL_1;
+ const static RxFlags RX_ACCEL_2;
+ const static RxFlags RX_ACCEL_3;
+ const static RxFlags RX_ACCEL_4;
+ const static RxFlags RX_ACCEL_5;
+ const static RxFlags RX_ACCEL_6;
+ const static RxFlags RX_ACCEL_7;
+ const static RxFlags RX_ACCEL_8;
+ const static RxFlags RX_ACCEL_9;
+ const static RxFlags RX_ACCEL_10;
+ const static RxFlags RX_ACCEL_11;
+ const static RxFlags RX_ACCEL_12;
+ const static RxFlags RX_ACCEL_13;
+ const static RxFlags RX_ACCEL_14;
+ const static RxFlags RX_ACCEL_15;
+ const static RxFlags RX_OVERRUN;
+ const static RxFlags RX_VALIDATION_ERROR;
+ const static RxFlags RX_ECHOED_TX;
+ const static RxFlags mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const RxFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const RxFlags& other) const { return value_ != other.value_; }
+ constexpr inline RxFlags operator~() const;
+ constexpr inline RxFlags operator|(const RxFlags& other) const;
+ constexpr inline RxFlags operator&(const RxFlags& other) const;
+ constexpr inline RxFlags operator^(const RxFlags& other) const;
+ constexpr inline void operator|=(const RxFlags& other);
+ constexpr inline void operator&=(const RxFlags& other);
+ constexpr inline void operator^=(const RxFlags& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_0 = ::llcpp::fuchsia::hardware::network::RxFlags(1u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_1 = ::llcpp::fuchsia::hardware::network::RxFlags(2u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_2 = ::llcpp::fuchsia::hardware::network::RxFlags(4u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_3 = ::llcpp::fuchsia::hardware::network::RxFlags(8u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_4 = ::llcpp::fuchsia::hardware::network::RxFlags(16u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_5 = ::llcpp::fuchsia::hardware::network::RxFlags(32u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_6 = ::llcpp::fuchsia::hardware::network::RxFlags(64u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_7 = ::llcpp::fuchsia::hardware::network::RxFlags(128u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_8 = ::llcpp::fuchsia::hardware::network::RxFlags(256u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_9 = ::llcpp::fuchsia::hardware::network::RxFlags(512u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_10 = ::llcpp::fuchsia::hardware::network::RxFlags(1024u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_11 = ::llcpp::fuchsia::hardware::network::RxFlags(2048u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_12 = ::llcpp::fuchsia::hardware::network::RxFlags(4096u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_13 = ::llcpp::fuchsia::hardware::network::RxFlags(8192u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_14 = ::llcpp::fuchsia::hardware::network::RxFlags(16384u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ACCEL_15 = ::llcpp::fuchsia::hardware::network::RxFlags(32768u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_OVERRUN = ::llcpp::fuchsia::hardware::network::RxFlags(536870912u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_VALIDATION_ERROR = ::llcpp::fuchsia::hardware::network::RxFlags(1073741824u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::RX_ECHOED_TX = ::llcpp::fuchsia::hardware::network::RxFlags(2147483648u);
+constexpr const ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::mask = ::llcpp::fuchsia::hardware::network::RxFlags(3758161919u);
+
+constexpr inline ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::operator~() const {
+ return ::llcpp::fuchsia::hardware::network::RxFlags(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::operator|(
+ const ::llcpp::fuchsia::hardware::network::RxFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::RxFlags(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::operator&(
+ const ::llcpp::fuchsia::hardware::network::RxFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::RxFlags(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::RxFlags RxFlags::operator^(
+ const ::llcpp::fuchsia::hardware::network::RxFlags& other) const {
+ return ::llcpp::fuchsia::hardware::network::RxFlags(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void RxFlags::operator|=(
+ const ::llcpp::fuchsia::hardware::network::RxFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void RxFlags::operator&=(
+ const ::llcpp::fuchsia::hardware::network::RxFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void RxFlags::operator^=(
+ const ::llcpp::fuchsia::hardware::network::RxFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+enum class RxAcceleration : uint8_t {
+ VALIDATED_ETHERNET_FCS = 0u,
+ VALIDATED_IPV4_CHECKSUM = 1u,
+ VALIDATED_TCP_CHECKSUM = 2u,
+ VALIDATED_UDP_CHECKSUM = 3u,
+};
+
+
+enum class MacFilterMode : uint32_t {
+ MULTICAST_FILTER = 0u,
+ MULTICAST_PROMISCUOUS = 1u,
+ PROMISCUOUS = 2u,
+};
+
+
+class MacAddressing;
+enum class InfoType : uint32_t {
+ NO_INFO = 0u,
+};
+
+
+enum class FrameType : uint8_t {
+ ETHERNET = 1u,
+ IPV4 = 2u,
+ IPV6 = 3u,
+};
+
+
+struct SessionInfo;
+struct FrameTypeSupport;
+struct Fifos;
+struct Device_OpenSession_Response;
+struct Device_OpenSession_Result;
+class EthernetFeatures final {
+public:
+ constexpr EthernetFeatures() : value_(0u) {}
+ explicit constexpr EthernetFeatures(uint32_t value) : value_(value) {}
+ const static EthernetFeatures RAW;
+ const static EthernetFeatures ETHERNET_II;
+ const static EthernetFeatures E_802_1_Q;
+ const static EthernetFeatures E_802_1_Q_IN_Q;
+ const static EthernetFeatures E_802_3_LLC_SNAP;
+ const static EthernetFeatures mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const EthernetFeatures& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const EthernetFeatures& other) const { return value_ != other.value_; }
+ constexpr inline EthernetFeatures operator~() const;
+ constexpr inline EthernetFeatures operator|(const EthernetFeatures& other) const;
+ constexpr inline EthernetFeatures operator&(const EthernetFeatures& other) const;
+ constexpr inline EthernetFeatures operator^(const EthernetFeatures& other) const;
+ constexpr inline void operator|=(const EthernetFeatures& other);
+ constexpr inline void operator&=(const EthernetFeatures& other);
+ constexpr inline void operator^=(const EthernetFeatures& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::RAW = ::llcpp::fuchsia::hardware::network::EthernetFeatures(1u);
+constexpr const ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::ETHERNET_II = ::llcpp::fuchsia::hardware::network::EthernetFeatures(2u);
+constexpr const ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::E_802_1_Q = ::llcpp::fuchsia::hardware::network::EthernetFeatures(4u);
+constexpr const ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::E_802_1_Q_IN_Q = ::llcpp::fuchsia::hardware::network::EthernetFeatures(8u);
+constexpr const ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::E_802_3_LLC_SNAP = ::llcpp::fuchsia::hardware::network::EthernetFeatures(16u);
+constexpr const ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::mask = ::llcpp::fuchsia::hardware::network::EthernetFeatures(31u);
+
+constexpr inline ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::operator~() const {
+ return ::llcpp::fuchsia::hardware::network::EthernetFeatures(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::operator|(
+ const ::llcpp::fuchsia::hardware::network::EthernetFeatures& other) const {
+ return ::llcpp::fuchsia::hardware::network::EthernetFeatures(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::operator&(
+ const ::llcpp::fuchsia::hardware::network::EthernetFeatures& other) const {
+ return ::llcpp::fuchsia::hardware::network::EthernetFeatures(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::hardware::network::EthernetFeatures EthernetFeatures::operator^(
+ const ::llcpp::fuchsia::hardware::network::EthernetFeatures& other) const {
+ return ::llcpp::fuchsia::hardware::network::EthernetFeatures(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void EthernetFeatures::operator|=(
+ const ::llcpp::fuchsia::hardware::network::EthernetFeatures& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void EthernetFeatures::operator&=(
+ const ::llcpp::fuchsia::hardware::network::EthernetFeatures& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void EthernetFeatures::operator^=(
+ const ::llcpp::fuchsia::hardware::network::EthernetFeatures& other) {
+ this->value_ ^= other.value_;
+}
+
+enum class DeviceClass : uint16_t {
+ UNKNOWN = 0u,
+ ETHERNET = 1u,
+ WLAN = 2u,
+ PPP = 3u,
+ BRIDGE = 4u,
+};
+
+
+struct Info;
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_StatusTable;
+
+// Dynamic device information.
+struct Status final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Device status flags.
+ const ::llcpp::fuchsia::hardware::network::StatusFlags& flags() const {
+ ZX_ASSERT(has_flags());
+ return *reinterpret_cast<const ::llcpp::fuchsia::hardware::network::StatusFlags*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::hardware::network::StatusFlags& flags() {
+ ZX_ASSERT(has_flags());
+ return *reinterpret_cast<::llcpp::fuchsia::hardware::network::StatusFlags*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_flags() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Maximum transmit unit for this device, in bytes. The reported `MTU` is the size of an ENTIRE
+ // frame, including any header and trailer bytes for whatever protocol the
+ // [`fuchsia.hardware.network/FrameType`]s of this device support.
+ const uint32_t& mtu() const {
+ ZX_ASSERT(has_mtu());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ uint32_t& mtu() {
+ ZX_ASSERT(has_mtu());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_mtu() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ Status() = default;
+ ~Status() = default;
+ Status(Status&& other) noexcept = default;
+ Status& operator=(Status&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_StatusTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 48;
+ static constexpr bool HasPointer = true;
+
+ private:
+ Status(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class Status::Builder {
+ public:
+ Status view() { return Status(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Device status flags.
+ Builder&& set_flags(::llcpp::fuchsia::hardware::network::StatusFlags* elem);
+
+ // Maximum transmit unit for this device, in bytes. The reported `MTU` is the size of an ENTIRE
+ // frame, including any header and trailer bytes for whatever protocol the
+ // [`fuchsia.hardware.network/FrameType`]s of this device support.
+ Builder&& set_mtu(uint32_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder Status::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 2> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_Device_OpenSession_ResultTable;
+
+struct Device_OpenSession_Result {
+ Device_OpenSession_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Device_OpenSession_Result WithResponse(::llcpp::fuchsia::hardware::network::Device_OpenSession_Response* val) {
+ Device_OpenSession_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::network::Device_OpenSession_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::network::Device_OpenSession_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::network::Device_OpenSession_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::network::Device_OpenSession_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::network::Device_OpenSession_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Device_OpenSession_Result WithErr(int32_t* val) {
+ Device_OpenSession_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_Device_OpenSession_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionSetPausedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionSetPausedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionCloseResponseTable;
+
+// Represents a session with a Network device.
+// A session has a data plane and a control plane. The `Session` protocol represents the control
+// plane of the session and the FIFOs and VMOs exchanged during the
+// [`fuchsia.hardware.network/Device.OpenSession`] call are the data plane. Lifetime of the session
+// is controlled by a `Session` protocol handle. Sessions are always created in a paused state.
+class Session final {
+ Session() = delete;
+ public:
+
+ struct SetPausedRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool paused;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_SessionSetPausedRequestTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class SetPaused_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetPaused_Impl(::zx::unowned_channel _client_end, bool paused);
+ ~SetPaused_Impl() = default;
+ SetPaused_Impl(SetPaused_Impl&& other) = default;
+ SetPaused_Impl& operator=(SetPaused_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using SetPaused = SetPaused_Impl;
+ using Close = Close_Impl;
+ };
+
+ // 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:
+ class SetPaused_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetPaused_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool paused);
+ ~SetPaused_Impl() = default;
+ SetPaused_Impl(SetPaused_Impl&& other) = default;
+ SetPaused_Impl& operator=(SetPaused_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using SetPaused = SetPaused_Impl;
+ using Close = Close_Impl;
+ };
+
+ 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_; }
+
+ // Pauses or unpauses reception of frames on this session.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetPaused SetPaused(bool paused);
+
+ // Pauses or unpauses reception of frames on this session.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetPaused SetPaused(::fidl::BytePart _request_buffer, bool paused);
+
+ // Cleanly closes a session. This will cause the session to send a `ZX_ERR_CANCELLED` epitaph
+ // and proceed to close the Session channel. Clients may only assume that they own all the
+ // buffers that are currently owned by the session (sent over either the Rx or Tx FIFOs) once
+ // the epitaph is received. Closing the Rx or Tx FIFO is equivalent to calling `Close`.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ 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:
+
+ // Pauses or unpauses reception of frames on this session.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetPaused SetPaused(::zx::unowned_channel _client_end, bool paused);
+
+ // Pauses or unpauses reception of frames on this session.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetPaused SetPaused(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool paused);
+
+ // Cleanly closes a session. This will cause the session to send a `ZX_ERR_CANCELLED` epitaph
+ // and proceed to close the Session channel. Clients may only assume that they own all the
+ // buffers that are currently owned by the session (sent over either the Rx or Tx FIFOs) once
+ // the epitaph is received. Closing the Rx or Tx FIFO is equivalent to calling `Close`.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // Pauses or unpauses reception of frames on this session.
+ static ::fidl::internal::StatusAndError SetPaused(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPausedRequest> params);
+
+ // Cleanly closes a session. This will cause the session to send a `ZX_ERR_CANCELLED` epitaph
+ // and proceed to close the Session channel. Clients may only assume that they own all the
+ // buffers that are currently owned by the session (sent over either the Rx or Tx FIFOs) once
+ // the epitaph is received. Closing the Rx or Tx FIFO is equivalent to calling `Close`.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Session;
+ using _Base = ::fidl::CompleterBase;
+
+ using SetPausedCompleter = ::fidl::Completer<>;
+
+ virtual void SetPaused(bool paused, SetPausedCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::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 SetPausedRequest(const ::fidl::DecodedMessage<Session::SetPausedRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Session::CloseRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceInstanceGetDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceInstanceGetDeviceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceInstanceGetMacAddressingRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceInstanceGetMacAddressingResponseTable;
+
+// An instance of a network device that may be capable of MAC address filtering.
+class DeviceInstance final {
+ DeviceInstance() = delete;
+ public:
+
+ struct GetDeviceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel device;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_DeviceInstanceGetDeviceRequestTable;
+ 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;
+ };
+
+ struct GetMacAddressingRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel mac;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_DeviceInstanceGetMacAddressingRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class GetDevice_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel device);
+ ~GetDevice_Impl() = default;
+ GetDevice_Impl(GetDevice_Impl&& other) = default;
+ GetDevice_Impl& operator=(GetDevice_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class GetMacAddressing_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetMacAddressing_Impl(::zx::unowned_channel _client_end, ::zx::channel mac);
+ ~GetMacAddressing_Impl() = default;
+ GetMacAddressing_Impl(GetMacAddressing_Impl&& other) = default;
+ GetMacAddressing_Impl& operator=(GetMacAddressing_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using GetDevice = GetDevice_Impl;
+ using GetMacAddressing = GetMacAddressing_Impl;
+ };
+
+ // 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:
+ class GetDevice_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device);
+ ~GetDevice_Impl() = default;
+ GetDevice_Impl(GetDevice_Impl&& other) = default;
+ GetDevice_Impl& operator=(GetDevice_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class GetMacAddressing_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetMacAddressing_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel mac);
+ ~GetMacAddressing_Impl() = default;
+ GetMacAddressing_Impl(GetMacAddressing_Impl&& other) = default;
+ GetMacAddressing_Impl& operator=(GetMacAddressing_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using GetDevice = GetDevice_Impl;
+ using GetMacAddressing = GetMacAddressing_Impl;
+ };
+
+ 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_; }
+
+ // Connects to the [`fuchsia.hardware.network/Device`] implementation, giving access to
+ // data-plane features.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDevice GetDevice(::zx::channel device);
+
+ // Connects to the [`fuchsia.hardware.network/Device`] implementation, giving access to
+ // data-plane features.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDevice GetDevice(::fidl::BytePart _request_buffer, ::zx::channel device);
+
+ // Connects to the [`fuchsia.hardware.network/MacAddressing`] implementation, giving access to
+ // MAC filtering control. `DeviceInstance`s that do not support `MacAddressing` will have the
+ // request immediately closed.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetMacAddressing GetMacAddressing(::zx::channel mac);
+
+ // Connects to the [`fuchsia.hardware.network/MacAddressing`] implementation, giving access to
+ // MAC filtering control. `DeviceInstance`s that do not support `MacAddressing` will have the
+ // request immediately closed.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetMacAddressing GetMacAddressing(::fidl::BytePart _request_buffer, ::zx::channel mac);
+
+ 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:
+
+ // Connects to the [`fuchsia.hardware.network/Device`] implementation, giving access to
+ // data-plane features.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDevice GetDevice(::zx::unowned_channel _client_end, ::zx::channel device);
+
+ // Connects to the [`fuchsia.hardware.network/Device`] implementation, giving access to
+ // data-plane features.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDevice GetDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel device);
+
+ // Connects to the [`fuchsia.hardware.network/MacAddressing`] implementation, giving access to
+ // MAC filtering control. `DeviceInstance`s that do not support `MacAddressing` will have the
+ // request immediately closed.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetMacAddressing GetMacAddressing(::zx::unowned_channel _client_end, ::zx::channel mac);
+
+ // Connects to the [`fuchsia.hardware.network/MacAddressing`] implementation, giving access to
+ // MAC filtering control. `DeviceInstance`s that do not support `MacAddressing` will have the
+ // request immediately closed.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetMacAddressing GetMacAddressing(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel mac);
+
+ };
+
+ // 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:
+
+ // Connects to the [`fuchsia.hardware.network/Device`] implementation, giving access to
+ // data-plane features.
+ static ::fidl::internal::StatusAndError GetDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetDeviceRequest> params);
+
+ // Connects to the [`fuchsia.hardware.network/MacAddressing`] implementation, giving access to
+ // MAC filtering control. `DeviceInstance`s that do not support `MacAddressing` will have the
+ // request immediately closed.
+ static ::fidl::internal::StatusAndError GetMacAddressing(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMacAddressingRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DeviceInstance;
+ using _Base = ::fidl::CompleterBase;
+
+ using GetDeviceCompleter = ::fidl::Completer<>;
+
+ virtual void GetDevice(::zx::channel device, GetDeviceCompleter::Sync _completer) = 0;
+
+ using GetMacAddressingCompleter = ::fidl::Completer<>;
+
+ virtual void GetMacAddressing(::zx::channel mac, GetMacAddressingCompleter::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 GetDeviceRequest(const ::fidl::DecodedMessage<DeviceInstance::GetDeviceRequest>& _msg);
+ static void GetMacAddressingRequest(const ::fidl::DecodedMessage<DeviceInstance::GetMacAddressingRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_StatusWatcherWatchStatusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_StatusWatcherWatchStatusResponseTable;
+
+// Provides a way to receive updates on device status changes.
+class StatusWatcher final {
+ StatusWatcher() = delete;
+ public:
+
+ struct WatchStatusResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::network::Status device_status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_StatusWatcherWatchStatusResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 48;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using WatchStatusRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class WatchStatus_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WatchStatus_Impl(::zx::unowned_channel _client_end);
+ ~WatchStatus_Impl() = default;
+ WatchStatus_Impl(WatchStatus_Impl&& other) = default;
+ WatchStatus_Impl& operator=(WatchStatus_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 WatchStatus = WatchStatus_Impl<WatchStatusResponse>;
+ };
+
+ // 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 WatchStatus_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WatchStatus_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WatchStatus_Impl() = default;
+ WatchStatus_Impl(WatchStatus_Impl&& other) = default;
+ WatchStatus_Impl& operator=(WatchStatus_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 WatchStatus = WatchStatus_Impl<WatchStatusResponse>;
+ };
+
+ 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_; }
+
+ // `WatchStatus` will block until the device's status has changed.
+ // The first call to `WatchStatus` will always return immediately with the current device
+ // status, subsequent calls will only complete when the device status differs from the last one
+ // that was returned through this `StatusWatcher`.
+ // If `StatusWatcher` was created with a buffer value larger than 1, `WatchStatus` may return a
+ // queued status change, depending on how many status changed happened since the last call to
+ // `WatchStatus`.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::WatchStatus WatchStatus();
+
+ // `WatchStatus` will block until the device's status has changed.
+ // The first call to `WatchStatus` will always return immediately with the current device
+ // status, subsequent calls will only complete when the device status differs from the last one
+ // that was returned through this `StatusWatcher`.
+ // If `StatusWatcher` was created with a buffer value larger than 1, `WatchStatus` may return a
+ // queued status change, depending on how many status changed happened since the last call to
+ // `WatchStatus`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WatchStatus WatchStatus(::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:
+
+ // `WatchStatus` will block until the device's status has changed.
+ // The first call to `WatchStatus` will always return immediately with the current device
+ // status, subsequent calls will only complete when the device status differs from the last one
+ // that was returned through this `StatusWatcher`.
+ // If `StatusWatcher` was created with a buffer value larger than 1, `WatchStatus` may return a
+ // queued status change, depending on how many status changed happened since the last call to
+ // `WatchStatus`.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::WatchStatus WatchStatus(::zx::unowned_channel _client_end);
+
+ // `WatchStatus` will block until the device's status has changed.
+ // The first call to `WatchStatus` will always return immediately with the current device
+ // status, subsequent calls will only complete when the device status differs from the last one
+ // that was returned through this `StatusWatcher`.
+ // If `StatusWatcher` was created with a buffer value larger than 1, `WatchStatus` may return a
+ // queued status change, depending on how many status changed happened since the last call to
+ // `WatchStatus`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WatchStatus WatchStatus(::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:
+
+ // `WatchStatus` will block until the device's status has changed.
+ // The first call to `WatchStatus` will always return immediately with the current device
+ // status, subsequent calls will only complete when the device status differs from the last one
+ // that was returned through this `StatusWatcher`.
+ // If `StatusWatcher` was created with a buffer value larger than 1, `WatchStatus` may return a
+ // queued status change, depending on how many status changed happened since the last call to
+ // `WatchStatus`.
+ static ::fidl::DecodeResult<WatchStatusResponse> WatchStatus(::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 = StatusWatcher;
+ using _Base = ::fidl::CompleterBase;
+
+ class WatchStatusCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::network::Status device_status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::network::Status device_status);
+ void Reply(::fidl::DecodedMessage<WatchStatusResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchStatusCompleter = ::fidl::Completer<WatchStatusCompleterBase>;
+
+ virtual void WatchStatus(WatchStatusCompleter::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 WatchStatusRequest(const ::fidl::DecodedMessage<StatusWatcher::WatchStatusRequest>& _msg);
+ static void WatchStatusResponse(const ::fidl::DecodedMessage<StatusWatcher::WatchStatusResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingGetUnicastAddressRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingGetUnicastAddressResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingSetModeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingSetModeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingAddMulticastAddressRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingAddMulticastAddressResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingRemoveMulticastAddressRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_MacAddressingRemoveMulticastAddressResponseTable;
+
+class MacAddressing final {
+ MacAddressing() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.hardware.network.MacAddressing";
+
+ struct GetUnicastAddressResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::net::MacAddress address;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_MacAddressingGetUnicastAddressResponseTable;
+ 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 GetUnicastAddressRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetModeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_MacAddressingSetModeResponseTable;
+ 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 SetModeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::network::MacFilterMode mode;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_MacAddressingSetModeRequestTable;
+ 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 = SetModeResponse;
+ };
+
+ struct AddMulticastAddressResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_MacAddressingAddMulticastAddressResponseTable;
+ 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 AddMulticastAddressRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::net::MacAddress address;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_MacAddressingAddMulticastAddressRequestTable;
+ 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 = AddMulticastAddressResponse;
+ };
+
+ struct RemoveMulticastAddressResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_MacAddressingRemoveMulticastAddressResponseTable;
+ 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 RemoveMulticastAddressRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::net::MacAddress address;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_MacAddressingRemoveMulticastAddressRequestTable;
+ 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 = RemoveMulticastAddressResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetUnicastAddress_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetUnicastAddress_Impl(::zx::unowned_channel _client_end);
+ ~GetUnicastAddress_Impl() = default;
+ GetUnicastAddress_Impl(GetUnicastAddress_Impl&& other) = default;
+ GetUnicastAddress_Impl& operator=(GetUnicastAddress_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 SetMode_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetMode_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::network::MacFilterMode mode);
+ ~SetMode_Impl() = default;
+ SetMode_Impl(SetMode_Impl&& other) = default;
+ SetMode_Impl& operator=(SetMode_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 AddMulticastAddress_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AddMulticastAddress_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::MacAddress address);
+ ~AddMulticastAddress_Impl() = default;
+ AddMulticastAddress_Impl(AddMulticastAddress_Impl&& other) = default;
+ AddMulticastAddress_Impl& operator=(AddMulticastAddress_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 RemoveMulticastAddress_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RemoveMulticastAddress_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::MacAddress address);
+ ~RemoveMulticastAddress_Impl() = default;
+ RemoveMulticastAddress_Impl(RemoveMulticastAddress_Impl&& other) = default;
+ RemoveMulticastAddress_Impl& operator=(RemoveMulticastAddress_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 GetUnicastAddress = GetUnicastAddress_Impl<GetUnicastAddressResponse>;
+ using SetMode = SetMode_Impl<SetModeResponse>;
+ using AddMulticastAddress = AddMulticastAddress_Impl<AddMulticastAddressResponse>;
+ using RemoveMulticastAddress = RemoveMulticastAddress_Impl<RemoveMulticastAddressResponse>;
+ };
+
+ // 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 GetUnicastAddress_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetUnicastAddress_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetUnicastAddress_Impl() = default;
+ GetUnicastAddress_Impl(GetUnicastAddress_Impl&& other) = default;
+ GetUnicastAddress_Impl& operator=(GetUnicastAddress_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 SetMode_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetMode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::network::MacFilterMode mode, ::fidl::BytePart _response_buffer);
+ ~SetMode_Impl() = default;
+ SetMode_Impl(SetMode_Impl&& other) = default;
+ SetMode_Impl& operator=(SetMode_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 AddMulticastAddress_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AddMulticastAddress_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer);
+ ~AddMulticastAddress_Impl() = default;
+ AddMulticastAddress_Impl(AddMulticastAddress_Impl&& other) = default;
+ AddMulticastAddress_Impl& operator=(AddMulticastAddress_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 RemoveMulticastAddress_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RemoveMulticastAddress_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer);
+ ~RemoveMulticastAddress_Impl() = default;
+ RemoveMulticastAddress_Impl(RemoveMulticastAddress_Impl&& other) = default;
+ RemoveMulticastAddress_Impl& operator=(RemoveMulticastAddress_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 GetUnicastAddress = GetUnicastAddress_Impl<GetUnicastAddressResponse>;
+ using SetMode = SetMode_Impl<SetModeResponse>;
+ using AddMulticastAddress = AddMulticastAddress_Impl<AddMulticastAddressResponse>;
+ using RemoveMulticastAddress = RemoveMulticastAddress_Impl<RemoveMulticastAddressResponse>;
+ };
+
+ 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_; }
+
+ // Gets the Device's current unicast MAC address.
+ // Implementers of this API do not need to return a uniquely identifiable MAC; the unicast
+ // address returned is the one that is *currently* in use to filter unicast frames, or that
+ // identifies the device on a link it's *currently* on. Users of this API must not rely on the
+ // stability or uniqueness of the returned value to identify or disambiguate device instances.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetUnicastAddress GetUnicastAddress();
+
+ // Gets the Device's current unicast MAC address.
+ // Implementers of this API do not need to return a uniquely identifiable MAC; the unicast
+ // address returned is the one that is *currently* in use to filter unicast frames, or that
+ // identifies the device on a link it's *currently* on. Users of this API must not rely on the
+ // stability or uniqueness of the returned value to identify or disambiguate device instances.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetUnicastAddress GetUnicastAddress(::fidl::BytePart _response_buffer);
+
+ // Sets requested operating mode of this device to `mode`.
+ //
+ // The requested mode is attached to the current client connection to the device. Because
+ // multiple clients can be attached to the same device at once, the mode with the least
+ // restrictions will be the one actively put into effect into the underlying device
+ // implementation.
+ //
+ // If the device does not support the requested mode, but supports a mode that is more open
+ // than the requested one, `SetMode` will succeed regardless. Otherwise, if the device only
+ // supports *more restrictive* modes than the one requested, `SetMode` returns
+ // `ZX_ERR_NOT_SUPPORTED`.
+ //
+ // Clients must be aware that the resource being accessed is shared, and that the device may be
+ // effectively operating at a more open level than the one that was requested (although never
+ // at one more restrictive).
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetMode SetMode(::llcpp::fuchsia::hardware::network::MacFilterMode mode);
+
+ // Sets requested operating mode of this device to `mode`.
+ //
+ // The requested mode is attached to the current client connection to the device. Because
+ // multiple clients can be attached to the same device at once, the mode with the least
+ // restrictions will be the one actively put into effect into the underlying device
+ // implementation.
+ //
+ // If the device does not support the requested mode, but supports a mode that is more open
+ // than the requested one, `SetMode` will succeed regardless. Otherwise, if the device only
+ // supports *more restrictive* modes than the one requested, `SetMode` returns
+ // `ZX_ERR_NOT_SUPPORTED`.
+ //
+ // Clients must be aware that the resource being accessed is shared, and that the device may be
+ // effectively operating at a more open level than the one that was requested (although never
+ // at one more restrictive).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetMode SetMode(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::network::MacFilterMode mode, ::fidl::BytePart _response_buffer);
+
+ // Adds multicast address to the list of multicast groups.
+ //
+ // The list of multicast addresses kept is untouched by calls to `SetMode`. If the device's
+ // mode is not `MULTICAST_FILTER`, the list of multicast addresses is ignored.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AddMulticastAddress AddMulticastAddress(::llcpp::fuchsia::net::MacAddress address);
+
+ // Adds multicast address to the list of multicast groups.
+ //
+ // The list of multicast addresses kept is untouched by calls to `SetMode`. If the device's
+ // mode is not `MULTICAST_FILTER`, the list of multicast addresses is ignored.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddMulticastAddress AddMulticastAddress(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer);
+
+ // Removes multicast address from the list of multicast groups.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RemoveMulticastAddress RemoveMulticastAddress(::llcpp::fuchsia::net::MacAddress address);
+
+ // Removes multicast address from the list of multicast groups.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RemoveMulticastAddress RemoveMulticastAddress(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::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:
+
+ // Gets the Device's current unicast MAC address.
+ // Implementers of this API do not need to return a uniquely identifiable MAC; the unicast
+ // address returned is the one that is *currently* in use to filter unicast frames, or that
+ // identifies the device on a link it's *currently* on. Users of this API must not rely on the
+ // stability or uniqueness of the returned value to identify or disambiguate device instances.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetUnicastAddress GetUnicastAddress(::zx::unowned_channel _client_end);
+
+ // Gets the Device's current unicast MAC address.
+ // Implementers of this API do not need to return a uniquely identifiable MAC; the unicast
+ // address returned is the one that is *currently* in use to filter unicast frames, or that
+ // identifies the device on a link it's *currently* on. Users of this API must not rely on the
+ // stability or uniqueness of the returned value to identify or disambiguate device instances.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetUnicastAddress GetUnicastAddress(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets requested operating mode of this device to `mode`.
+ //
+ // The requested mode is attached to the current client connection to the device. Because
+ // multiple clients can be attached to the same device at once, the mode with the least
+ // restrictions will be the one actively put into effect into the underlying device
+ // implementation.
+ //
+ // If the device does not support the requested mode, but supports a mode that is more open
+ // than the requested one, `SetMode` will succeed regardless. Otherwise, if the device only
+ // supports *more restrictive* modes than the one requested, `SetMode` returns
+ // `ZX_ERR_NOT_SUPPORTED`.
+ //
+ // Clients must be aware that the resource being accessed is shared, and that the device may be
+ // effectively operating at a more open level than the one that was requested (although never
+ // at one more restrictive).
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetMode SetMode(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::network::MacFilterMode mode);
+
+ // Sets requested operating mode of this device to `mode`.
+ //
+ // The requested mode is attached to the current client connection to the device. Because
+ // multiple clients can be attached to the same device at once, the mode with the least
+ // restrictions will be the one actively put into effect into the underlying device
+ // implementation.
+ //
+ // If the device does not support the requested mode, but supports a mode that is more open
+ // than the requested one, `SetMode` will succeed regardless. Otherwise, if the device only
+ // supports *more restrictive* modes than the one requested, `SetMode` returns
+ // `ZX_ERR_NOT_SUPPORTED`.
+ //
+ // Clients must be aware that the resource being accessed is shared, and that the device may be
+ // effectively operating at a more open level than the one that was requested (although never
+ // at one more restrictive).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetMode SetMode(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::network::MacFilterMode mode, ::fidl::BytePart _response_buffer);
+
+ // Adds multicast address to the list of multicast groups.
+ //
+ // The list of multicast addresses kept is untouched by calls to `SetMode`. If the device's
+ // mode is not `MULTICAST_FILTER`, the list of multicast addresses is ignored.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AddMulticastAddress AddMulticastAddress(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::MacAddress address);
+
+ // Adds multicast address to the list of multicast groups.
+ //
+ // The list of multicast addresses kept is untouched by calls to `SetMode`. If the device's
+ // mode is not `MULTICAST_FILTER`, the list of multicast addresses is ignored.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddMulticastAddress AddMulticastAddress(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::fidl::BytePart _response_buffer);
+
+ // Removes multicast address from the list of multicast groups.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RemoveMulticastAddress RemoveMulticastAddress(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::MacAddress address);
+
+ // Removes multicast address from the list of multicast groups.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RemoveMulticastAddress RemoveMulticastAddress(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::MacAddress address, ::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:
+
+ // Gets the Device's current unicast MAC address.
+ // Implementers of this API do not need to return a uniquely identifiable MAC; the unicast
+ // address returned is the one that is *currently* in use to filter unicast frames, or that
+ // identifies the device on a link it's *currently* on. Users of this API must not rely on the
+ // stability or uniqueness of the returned value to identify or disambiguate device instances.
+ static ::fidl::DecodeResult<GetUnicastAddressResponse> GetUnicastAddress(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets requested operating mode of this device to `mode`.
+ //
+ // The requested mode is attached to the current client connection to the device. Because
+ // multiple clients can be attached to the same device at once, the mode with the least
+ // restrictions will be the one actively put into effect into the underlying device
+ // implementation.
+ //
+ // If the device does not support the requested mode, but supports a mode that is more open
+ // than the requested one, `SetMode` will succeed regardless. Otherwise, if the device only
+ // supports *more restrictive* modes than the one requested, `SetMode` returns
+ // `ZX_ERR_NOT_SUPPORTED`.
+ //
+ // Clients must be aware that the resource being accessed is shared, and that the device may be
+ // effectively operating at a more open level than the one that was requested (although never
+ // at one more restrictive).
+ static ::fidl::DecodeResult<SetModeResponse> SetMode(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetModeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Adds multicast address to the list of multicast groups.
+ //
+ // The list of multicast addresses kept is untouched by calls to `SetMode`. If the device's
+ // mode is not `MULTICAST_FILTER`, the list of multicast addresses is ignored.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ static ::fidl::DecodeResult<AddMulticastAddressResponse> AddMulticastAddress(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddMulticastAddressRequest> params, ::fidl::BytePart response_buffer);
+
+ // Removes multicast address from the list of multicast groups.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if the provided `address` is not a multicast address.
+ static ::fidl::DecodeResult<RemoveMulticastAddressResponse> RemoveMulticastAddress(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RemoveMulticastAddressRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = MacAddressing;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetUnicastAddressCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::net::MacAddress address);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::net::MacAddress address);
+ void Reply(::fidl::DecodedMessage<GetUnicastAddressResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetUnicastAddressCompleter = ::fidl::Completer<GetUnicastAddressCompleterBase>;
+
+ virtual void GetUnicastAddress(GetUnicastAddressCompleter::Sync _completer) = 0;
+
+ class SetModeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetModeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetModeCompleter = ::fidl::Completer<SetModeCompleterBase>;
+
+ virtual void SetMode(::llcpp::fuchsia::hardware::network::MacFilterMode mode, SetModeCompleter::Sync _completer) = 0;
+
+ class AddMulticastAddressCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<AddMulticastAddressResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AddMulticastAddressCompleter = ::fidl::Completer<AddMulticastAddressCompleterBase>;
+
+ virtual void AddMulticastAddress(::llcpp::fuchsia::net::MacAddress address, AddMulticastAddressCompleter::Sync _completer) = 0;
+
+ class RemoveMulticastAddressCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<RemoveMulticastAddressResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RemoveMulticastAddressCompleter = ::fidl::Completer<RemoveMulticastAddressCompleterBase>;
+
+ virtual void RemoveMulticastAddress(::llcpp::fuchsia::net::MacAddress address, RemoveMulticastAddressCompleter::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 GetUnicastAddressRequest(const ::fidl::DecodedMessage<MacAddressing::GetUnicastAddressRequest>& _msg);
+ static void GetUnicastAddressResponse(const ::fidl::DecodedMessage<MacAddressing::GetUnicastAddressResponse>& _msg);
+ static void SetModeRequest(const ::fidl::DecodedMessage<MacAddressing::SetModeRequest>& _msg);
+ static void SetModeResponse(const ::fidl::DecodedMessage<MacAddressing::SetModeResponse>& _msg);
+ static void AddMulticastAddressRequest(const ::fidl::DecodedMessage<MacAddressing::AddMulticastAddressRequest>& _msg);
+ static void AddMulticastAddressResponse(const ::fidl::DecodedMessage<MacAddressing::AddMulticastAddressResponse>& _msg);
+ static void RemoveMulticastAddressRequest(const ::fidl::DecodedMessage<MacAddressing::RemoveMulticastAddressRequest>& _msg);
+ static void RemoveMulticastAddressResponse(const ::fidl::DecodedMessage<MacAddressing::RemoveMulticastAddressResponse>& _msg);
+ };
+};
+
+// The maximum number of status samples that can be buffered by a
+// [`fuchsia.hardware.network/StatusWatcher`].
+constexpr uint32_t MAX_STATUS_BUFFER = 50u;
+
+// Maximum length of session label.
+constexpr uint32_t MAX_SESSION_NAME = 64u;
+
+// Maximum numbers of supported frame types for Rx or Tx.
+constexpr uint32_t MAX_FRAME_TYPES = 4u;
+
+// Maximum number of chained descriptors that describe a single frame.
+constexpr uint8_t MAX_DESCRIPTOR_CHAIN = 4u;
+
+// Maximum number of acceleration flags.
+// Each descriptor has 16 bits of space for acceleration flags
+// ([`fuchsia.hardware.network/RxFlags`] and [`fuchsia.hardware.network/TxFlags`]) thus the maximum
+// number of reported accelerations is 16. Each descriptor reports which accelerations were applied
+// (`RxFlags`) or are requested (`TxFlags`) by mapping indexes in the vector of supported
+// accelerations ([`fuchsia.hardware.network/Info.rx_accel`] and
+// ([`fuchsia.hardware.network/Info.tx_accel`]) to bits in the respective acceleration flags
+// bitfield.
+constexpr uint32_t MAX_ACCEL_FLAGS = 16u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_SessionInfoTable;
+
+// Session configuration.
+struct SessionInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_SessionInfoTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ // VMO containing the descriptors. 16-bit indices transmitted over the FIFOs index a descriptor
+ // in this VMO (byte offset = descriptor_length * 8 * index).
+ ::zx::vmo descriptors = {};
+
+ // VMO containing frame data. Descriptors contain byte-offsets that are used to index
+ // arbitrary regions in `data`.
+ ::zx::vmo data = {};
+
+ // Requested descriptor version. If the network device does not support the requested
+ // descriptor version, [`fuchsia.hardware.network/Device.OpenSession`] will fail with
+ // `ZX_ERR_NOT_SUPPORTED`.
+ uint8_t descriptor_version = {};
+
+ // Descriptor length, in 64-bit words. The length of each descriptor in the `descriptors` VMO.
+ // This is used as a multiplier to find byte offsets in `descriptors` given a descriptor index
+ // passed through the Rx or Tx FIFOs.
+ uint8_t descriptor_length = {};
+
+ // Total number of descriptors that can be used by this session. Descriptor indices transferred
+ // through either the Rx or Tx FIFO must be in the range [0, `descriptor_count`).
+ uint16_t descriptor_count = {};
+
+ // Extra options.
+ ::llcpp::fuchsia::hardware::network::SessionFlags options = {};
+
+ // List of frame types the client is subscribing to.
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::network::FrameType> rx_frames = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_FrameTypeSupportTable;
+
+// Specifies a frame type and features and supported flags associated with that type.
+// This is used by clients to read the supported frames on the Tx path for a given
+// Network Device.
+// Some Network Devices may parse outgoing frames to perform frame transformation or specific
+// hardware support. Each frame type has an associated
+// [`fuchsia.hardware.network/FrameTypeSupport.features`] bits enumeration that lists
+// FrameType-specific features that may or may not be supported. Devices that do not perform
+// parsing are encouraged to just use the [`fuchsia.hardware.network/FRAME_FEATURES_RAW`] bit in
+// `features`, which will inform the client that all frame features are allowed.
+struct FrameTypeSupport {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_FrameTypeSupportTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 12;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The frame type this support entry refers to.
+ ::llcpp::fuchsia::hardware::network::FrameType type = {};
+
+ // The frame type-specific features supported.
+ uint32_t features = {};
+
+ // The flags supported for the given frame type.
+ ::llcpp::fuchsia::hardware::network::TxFlags supported_flags = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_FifosTable;
+
+// Data-plane FIFOs.
+struct Fifos {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_FifosTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Handle for the rx FIFO.
+ // Clients must write 16-bit descriptor indexes to this FIFO to be able to receive
+ // frames.
+ ::zx::fifo rx = {};
+
+ // Handle for the tx FIFO.
+ // Clients write 16-bit descriptor indexes to this FIFO to enqueue outgoing frames.
+ ::zx::fifo tx = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_Device_OpenSession_ResponseTable;
+
+struct Device_OpenSession_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_Device_OpenSession_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 12;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::channel session = {};
+
+ ::llcpp::fuchsia::hardware::network::Fifos fifos = {};
+};
+
+// Blanket definition for raw frames. Devices that do not perform any sort of parsing of outbound
+// traffic should define `FRAME_FEATURES_RAW` in the [`fuchsia.hardware.network/FrameTypeSupport`]
+// entry.
+constexpr uint32_t FRAME_FEATURES_RAW = 1u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_InfoTable;
+
+// Network device information.
+struct Info {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_InfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 96;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 88;
+ static constexpr bool HasPointer = true;
+
+ // Device's class, defined in [`fuchsia.hardware.network/DeviceClass`].
+ ::llcpp::fuchsia::hardware::network::DeviceClass class_ = {};
+
+ // Minimum descriptor length, in 64-bit words.
+ // Expresses the minimum length that each buffer descriptor must have for correct operation
+ // with this device. Devices that support extra frame metadata inform larger minimum descriptor
+ // lengths that reflect the minimum space needed to be able to store frame metadata.
+ uint8_t min_descriptor_length = {};
+
+ // Accepted descriptor version.
+ uint8_t descriptor_version = {};
+
+ // Maximum number of items in Rx FIFO (per session).
+ // `rx_depth` is calculated based on the size of the actual backing hardware rx queue.
+ uint32_t rx_depth = {};
+
+ // Maximum number of items in Tx FIFO (per session).
+ // `tx_depth` is calculated based on the size of the actual backing hardware tx queue.
+ uint32_t tx_depth = {};
+
+ // Alignment requirement for buffers in the data VMO. All buffers in the data VMO *must* be
+ // aligned to `buffer_alignment` relative to the start of the VMO.
+ uint32_t buffer_alignment = {};
+
+ // Maximum supported length of buffers in the data VMO, in bytes.
+ uint32_t max_buffer_length = {};
+
+ // The minimum RX buffer length for correct operation, in bytes.
+ uint32_t min_rx_buffer_length = {};
+
+ // The number of bytes the device requests be free as `head` space in a Tx buffer. Devices
+ // may choose to reject Tx buffers that do not satisfy this constraint.
+ uint16_t min_tx_buffer_head = {};
+
+ // The amount of bytes the device requests be free as `tail` space in a Tx buffer. Devices
+ // may choose to reject Tx buffers that to not satisfy this constraint.
+ uint16_t min_tx_buffer_tail = {};
+
+ // Supported Rx frame types on this device.
+ //
+ // Clients may open sessions subscribing to a subset of `rx_types` frame types on this device.
+ // Clients will only receive the frame types they are subscribed to in this session
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::network::FrameType> rx_types = {};
+
+ // Supported Tx frame types on this device.
+ //
+ // A client is free to send any frame type on an open session, as long as the frame type is
+ // part of `tx_types`. Some network devices may need to perform partial frame parsing and
+ // serialization and, for that reason, `tx_types` is a vector of
+ // [`fuchsia.hardware.network/FrameTypeSupport`] which includes specific features per frame
+ // type.
+ //
+ // For example, a device that supports Ethernet frames but needs to convert the Ethernet header
+ // may only support standard EthernetII frames, and not any "raw" Ethernet frame.
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::network::FrameTypeSupport> tx_types = {};
+
+ // Available Rx acceleration flags for this device. `rx_accel` maps the `RX_ACCEL_*` flags in
+ // the frame descriptors with semantic acceleration features described by
+ // [`fuchsia.hardware.network/RxAcceleration`]. Position `n` of `rx_accel` conveys the meaning
+ // of the `RX_ACCEL_n` flag.
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::network::RxAcceleration> rx_accel = {};
+
+ // Available Tx acceleration flags for this device. `tx_accel` maps the `TX_ACCEL_*` flags in
+ // the frame descriptors with semantic acceleration features described by
+ // [`fuchsia.hardware.network/TxAcceleration]`. Position `n` of `tx_accel` conveys the meaning
+ // of the `TX_ACCEL_n` flag.
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::network::TxAcceleration> tx_accel = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetStatusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetStatusResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetStatusWatcherRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceGetStatusWatcherResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceOpenSessionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_network_DeviceOpenSessionResponseTable;
+
+// A Network Device.
+class Device final {
+ Device() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.hardware.network.Device";
+
+ struct GetInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::network::Info info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_DeviceGetInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 112;
+ static constexpr uint32_t MaxOutOfLine = 88;
+ 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 GetStatusResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::network::Status device_status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_DeviceGetStatusResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 48;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetStatusRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetStatusWatcherRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel watcher;
+ uint32_t buffer;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_DeviceGetStatusWatcherRequestTable;
+ 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;
+ };
+
+ struct OpenSessionResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::network::Device_OpenSession_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_DeviceOpenSessionResponseTable;
+ static constexpr uint32_t MaxNumHandles = 3;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct OpenSessionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView session_name;
+ ::llcpp::fuchsia::hardware::network::SessionInfo session_info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_network_DeviceOpenSessionRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 64;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr uint32_t AltPrimarySize = 64;
+ static constexpr uint32_t AltMaxOutOfLine = 72;
+ 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 = OpenSessionResponse;
+ };
+
+
+ // 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 GetStatus_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetStatus_Impl(::zx::unowned_channel _client_end);
+ ~GetStatus_Impl() = default;
+ GetStatus_Impl(GetStatus_Impl&& other) = default;
+ GetStatus_Impl& operator=(GetStatus_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class GetStatusWatcher_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetStatusWatcher_Impl(::zx::unowned_channel _client_end, ::zx::channel watcher, uint32_t buffer);
+ ~GetStatusWatcher_Impl() = default;
+ GetStatusWatcher_Impl(GetStatusWatcher_Impl&& other) = default;
+ GetStatusWatcher_Impl& operator=(GetStatusWatcher_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class OpenSession_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ OpenSession_Impl(::zx::unowned_channel _client_end, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info);
+ ~OpenSession_Impl() = default;
+ OpenSession_Impl(OpenSession_Impl&& other) = default;
+ OpenSession_Impl& operator=(OpenSession_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 GetStatus = GetStatus_Impl<GetStatusResponse>;
+ using GetStatusWatcher = GetStatusWatcher_Impl;
+ using OpenSession = OpenSession_Impl<OpenSessionResponse>;
+ };
+
+ // 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 GetStatus_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetStatus_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetStatus_Impl() = default;
+ GetStatus_Impl(GetStatus_Impl&& other) = default;
+ GetStatus_Impl& operator=(GetStatus_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class GetStatusWatcher_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetStatusWatcher_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel watcher, uint32_t buffer);
+ ~GetStatusWatcher_Impl() = default;
+ GetStatusWatcher_Impl(GetStatusWatcher_Impl&& other) = default;
+ GetStatusWatcher_Impl& operator=(GetStatusWatcher_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class OpenSession_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ OpenSession_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info, ::fidl::BytePart _response_buffer);
+ ~OpenSession_Impl() = default;
+ OpenSession_Impl(OpenSession_Impl&& other) = default;
+ OpenSession_Impl& operator=(OpenSession_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 GetStatus = GetStatus_Impl<GetStatusResponse>;
+ using GetStatusWatcher = GetStatusWatcher_Impl;
+ using OpenSession = OpenSession_Impl<OpenSessionResponse>;
+ };
+
+ 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_; }
+
+ // Obtain information about device
+ // Allocates 216 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetInfo GetInfo();
+
+ // Obtain information about device
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetInfo GetInfo(::fidl::BytePart _response_buffer);
+
+ // Obtain the operating device status.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetStatus GetStatus();
+
+ // Obtain the operating device status.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetStatus GetStatus(::fidl::BytePart _response_buffer);
+
+ // Connects to a [`fuchsia.hardware.network/StatusWatcher`] to observe device status changes.
+ //
+ // `buffer` is the number of status changes that the client requests to be stored by
+ // `StatusWatcher`, limited to [`fuchsia.hardware.network/MAX_STATUS_BUFFER`]. A value of 0 or
+ // 1 will cause the `StatusWatcher` to not keep any buffers on status changed. Clients that
+ // need to observe all changes to status (as opposed to only the current state) are encouraged
+ // to set a buffer value larger than 1, so that all edges can be observed. If `StatusWatcher`'s
+ // internal queue is filled and new status changes occur, the oldest samples will be dropped to
+ // make room for new ones.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetStatusWatcher GetStatusWatcher(::zx::channel watcher, uint32_t buffer);
+
+ // Connects to a [`fuchsia.hardware.network/StatusWatcher`] to observe device status changes.
+ //
+ // `buffer` is the number of status changes that the client requests to be stored by
+ // `StatusWatcher`, limited to [`fuchsia.hardware.network/MAX_STATUS_BUFFER`]. A value of 0 or
+ // 1 will cause the `StatusWatcher` to not keep any buffers on status changed. Clients that
+ // need to observe all changes to status (as opposed to only the current state) are encouraged
+ // to set a buffer value larger than 1, so that all edges can be observed. If `StatusWatcher`'s
+ // internal queue is filled and new status changes occur, the oldest samples will be dropped to
+ // make room for new ones.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetStatusWatcher GetStatusWatcher(::fidl::BytePart _request_buffer, ::zx::channel watcher, uint32_t buffer);
+
+ // Opens a new session with the network device.
+ // `session_name` is used only as a debug label.
+ // `session_info` contains the necessary information to setup the session's data exchange.
+ // Allocates 192 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::OpenSession OpenSession(::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info);
+
+ // Opens a new session with the network device.
+ // `session_name` is used only as a debug label.
+ // `session_info` contains the necessary information to setup the session's data exchange.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OpenSession OpenSession(::fidl::BytePart _request_buffer, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info, ::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:
+
+ // Obtain information about device
+ // Allocates 216 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end);
+
+ // Obtain information about device
+ // 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);
+
+ // Obtain the operating device status.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetStatus GetStatus(::zx::unowned_channel _client_end);
+
+ // Obtain the operating device status.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetStatus GetStatus(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Connects to a [`fuchsia.hardware.network/StatusWatcher`] to observe device status changes.
+ //
+ // `buffer` is the number of status changes that the client requests to be stored by
+ // `StatusWatcher`, limited to [`fuchsia.hardware.network/MAX_STATUS_BUFFER`]. A value of 0 or
+ // 1 will cause the `StatusWatcher` to not keep any buffers on status changed. Clients that
+ // need to observe all changes to status (as opposed to only the current state) are encouraged
+ // to set a buffer value larger than 1, so that all edges can be observed. If `StatusWatcher`'s
+ // internal queue is filled and new status changes occur, the oldest samples will be dropped to
+ // make room for new ones.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetStatusWatcher GetStatusWatcher(::zx::unowned_channel _client_end, ::zx::channel watcher, uint32_t buffer);
+
+ // Connects to a [`fuchsia.hardware.network/StatusWatcher`] to observe device status changes.
+ //
+ // `buffer` is the number of status changes that the client requests to be stored by
+ // `StatusWatcher`, limited to [`fuchsia.hardware.network/MAX_STATUS_BUFFER`]. A value of 0 or
+ // 1 will cause the `StatusWatcher` to not keep any buffers on status changed. Clients that
+ // need to observe all changes to status (as opposed to only the current state) are encouraged
+ // to set a buffer value larger than 1, so that all edges can be observed. If `StatusWatcher`'s
+ // internal queue is filled and new status changes occur, the oldest samples will be dropped to
+ // make room for new ones.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetStatusWatcher GetStatusWatcher(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel watcher, uint32_t buffer);
+
+ // Opens a new session with the network device.
+ // `session_name` is used only as a debug label.
+ // `session_info` contains the necessary information to setup the session's data exchange.
+ // Allocates 192 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::OpenSession OpenSession(::zx::unowned_channel _client_end, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info);
+
+ // Opens a new session with the network device.
+ // `session_name` is used only as a debug label.
+ // `session_info` contains the necessary information to setup the session's data exchange.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OpenSession OpenSession(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info, ::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:
+
+ // Obtain information about device
+ static ::fidl::DecodeResult<GetInfoResponse> GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Obtain the operating device status.
+ static ::fidl::DecodeResult<GetStatusResponse> GetStatus(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Connects to a [`fuchsia.hardware.network/StatusWatcher`] to observe device status changes.
+ //
+ // `buffer` is the number of status changes that the client requests to be stored by
+ // `StatusWatcher`, limited to [`fuchsia.hardware.network/MAX_STATUS_BUFFER`]. A value of 0 or
+ // 1 will cause the `StatusWatcher` to not keep any buffers on status changed. Clients that
+ // need to observe all changes to status (as opposed to only the current state) are encouraged
+ // to set a buffer value larger than 1, so that all edges can be observed. If `StatusWatcher`'s
+ // internal queue is filled and new status changes occur, the oldest samples will be dropped to
+ // make room for new ones.
+ static ::fidl::internal::StatusAndError GetStatusWatcher(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStatusWatcherRequest> params);
+
+ // Opens a new session with the network device.
+ // `session_name` is used only as a debug label.
+ // `session_info` contains the necessary information to setup the session's data exchange.
+ static ::fidl::DecodeResult<OpenSessionResponse> OpenSession(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenSessionRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetInfoCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::network::Info info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::network::Info 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 GetStatusCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::network::Status device_status);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::network::Status device_status);
+ void Reply(::fidl::DecodedMessage<GetStatusResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetStatusCompleter = ::fidl::Completer<GetStatusCompleterBase>;
+
+ virtual void GetStatus(GetStatusCompleter::Sync _completer) = 0;
+
+ using GetStatusWatcherCompleter = ::fidl::Completer<>;
+
+ virtual void GetStatusWatcher(::zx::channel watcher, uint32_t buffer, GetStatusWatcherCompleter::Sync _completer) = 0;
+
+ class OpenSessionCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::network::Device_OpenSession_Result result);
+ void ReplySuccess(::zx::channel session, ::llcpp::fuchsia::hardware::network::Fifos fifos);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::network::Device_OpenSession_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::channel session, ::llcpp::fuchsia::hardware::network::Fifos fifos);
+ void Reply(::fidl::DecodedMessage<OpenSessionResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using OpenSessionCompleter = ::fidl::Completer<OpenSessionCompleterBase>;
+
+ virtual void OpenSession(::fidl::StringView session_name, ::llcpp::fuchsia::hardware::network::SessionInfo session_info, OpenSessionCompleter::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<Device::GetInfoRequest>& _msg);
+ static void GetInfoResponse(const ::fidl::DecodedMessage<Device::GetInfoResponse>& _msg);
+ static void GetStatusRequest(const ::fidl::DecodedMessage<Device::GetStatusRequest>& _msg);
+ static void GetStatusResponse(const ::fidl::DecodedMessage<Device::GetStatusResponse>& _msg);
+ static void GetStatusWatcherRequest(const ::fidl::DecodedMessage<Device::GetStatusWatcherRequest>& _msg);
+ static void OpenSessionRequest(const ::fidl::DecodedMessage<Device::OpenSessionRequest>& _msg);
+ static void OpenSessionResponse(const ::fidl::DecodedMessage<Device::OpenSessionResponse>& _msg);
+ };
+};
+
+} // namespace network
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::TxReturnFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::TxReturnFlags>);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::TxReturnFlags) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::TxFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::TxFlags>);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::TxFlags) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::StatusFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::StatusFlags>);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::StatusFlags) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Status> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::Status>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Session::SetPausedRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::Session::SetPausedRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Session::SetPausedRequest)
+ == ::llcpp::fuchsia::hardware::network::Session::SetPausedRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Session::SetPausedRequest, paused) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::DeviceInstance::GetDeviceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::DeviceInstance::GetDeviceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::DeviceInstance::GetDeviceRequest)
+ == ::llcpp::fuchsia::hardware::network::DeviceInstance::GetDeviceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::DeviceInstance::GetDeviceRequest, device) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::DeviceInstance::GetMacAddressingRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::DeviceInstance::GetMacAddressingRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::DeviceInstance::GetMacAddressingRequest)
+ == ::llcpp::fuchsia::hardware::network::DeviceInstance::GetMacAddressingRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::DeviceInstance::GetMacAddressingRequest, mac) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::StatusWatcher::WatchStatusResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::StatusWatcher::WatchStatusResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::StatusWatcher::WatchStatusResponse)
+ == ::llcpp::fuchsia::hardware::network::StatusWatcher::WatchStatusResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::StatusWatcher::WatchStatusResponse, device_status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::SessionFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::SessionFlags>);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::SessionFlags) == sizeof(uint16_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::RxFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::RxFlags>);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::RxFlags) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::MacAddressing::GetUnicastAddressResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::MacAddressing::GetUnicastAddressResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::MacAddressing::GetUnicastAddressResponse)
+ == ::llcpp::fuchsia::hardware::network::MacAddressing::GetUnicastAddressResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::MacAddressing::GetUnicastAddressResponse, address) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::MacAddressing::SetModeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::MacAddressing::SetModeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::MacAddressing::SetModeRequest)
+ == ::llcpp::fuchsia::hardware::network::MacAddressing::SetModeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::MacAddressing::SetModeRequest, mode) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::MacAddressing::SetModeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::MacAddressing::SetModeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::MacAddressing::SetModeResponse)
+ == ::llcpp::fuchsia::hardware::network::MacAddressing::SetModeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::MacAddressing::SetModeResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressRequest)
+ == ::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressRequest, address) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressResponse)
+ == ::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::MacAddressing::AddMulticastAddressResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressRequest)
+ == ::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressRequest, address) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressResponse)
+ == ::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::MacAddressing::RemoveMulticastAddressResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::SessionInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::SessionInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::SessionInfo, descriptors) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::SessionInfo, data) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::SessionInfo, descriptor_version) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::SessionInfo, descriptor_length) == 9);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::SessionInfo, descriptor_count) == 10);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::SessionInfo, options) == 12);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::SessionInfo, rx_frames) == 16);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::SessionInfo) == ::llcpp::fuchsia::hardware::network::SessionInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::FrameTypeSupport> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::FrameTypeSupport>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::FrameTypeSupport, type) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::FrameTypeSupport, features) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::FrameTypeSupport, supported_flags) == 8);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::FrameTypeSupport) == ::llcpp::fuchsia::hardware::network::FrameTypeSupport::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Fifos> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::Fifos>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Fifos, rx) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Fifos, tx) == 4);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Fifos) == ::llcpp::fuchsia::hardware::network::Fifos::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Device_OpenSession_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::Device_OpenSession_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device_OpenSession_Response, session) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device_OpenSession_Response, fifos) == 4);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Device_OpenSession_Response) == ::llcpp::fuchsia::hardware::network::Device_OpenSession_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Device_OpenSession_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::Device_OpenSession_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::EthernetFeatures> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::EthernetFeatures>);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::EthernetFeatures) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Info> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::network::Info>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, class_) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, min_descriptor_length) == 2);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, descriptor_version) == 3);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, rx_depth) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, tx_depth) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, buffer_alignment) == 12);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, max_buffer_length) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, min_rx_buffer_length) == 20);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, min_tx_buffer_head) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, min_tx_buffer_tail) == 26);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, rx_types) == 32);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, tx_types) == 48);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, rx_accel) == 64);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Info, tx_accel) == 80);
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Info) == ::llcpp::fuchsia::hardware::network::Info::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Device::GetInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::Device::GetInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Device::GetInfoResponse)
+ == ::llcpp::fuchsia::hardware::network::Device::GetInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device::GetInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Device::GetStatusResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::Device::GetStatusResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Device::GetStatusResponse)
+ == ::llcpp::fuchsia::hardware::network::Device::GetStatusResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device::GetStatusResponse, device_status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Device::GetStatusWatcherRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::Device::GetStatusWatcherRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Device::GetStatusWatcherRequest)
+ == ::llcpp::fuchsia::hardware::network::Device::GetStatusWatcherRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device::GetStatusWatcherRequest, watcher) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device::GetStatusWatcherRequest, buffer) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Device::OpenSessionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::Device::OpenSessionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Device::OpenSessionRequest)
+ == ::llcpp::fuchsia::hardware::network::Device::OpenSessionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device::OpenSessionRequest, session_name) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device::OpenSessionRequest, session_info) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::network::Device::OpenSessionResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::network::Device::OpenSessionResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::network::Device::OpenSessionResponse)
+ == ::llcpp::fuchsia::hardware::network::Device::OpenSessionResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::network::Device::OpenSessionResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-pty/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-pty/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..64be616
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-pty/gen/llcpp/fidl.cc
@@ -0,0 +1,3113 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/pty/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace pty {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Read_Ordinal = 0x25f7418400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Read_GenOrdinal = 0x29b2b7074c95208clu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ReadAt_Ordinal = 0x7c724dc400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ReadAt_GenOrdinal = 0x6527ee3fbc9c5749lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadAtResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Write_Ordinal = 0x512e7a000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Write_GenOrdinal = 0x3b6432f57914225blu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_WriteAt_Ordinal = 0x3e5522e500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_WriteAt_GenOrdinal = 0x4b29e1582ab379e4lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteAtResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Seek_Ordinal = 0x782a774500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Seek_GenOrdinal = 0x324968e9b8a0e394lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSeekRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSeekResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Truncate_Ordinal = 0x42ab3a3a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Truncate_GenOrdinal = 0x5ec8f337359a2ddblu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceTruncateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceTruncateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetFlags_Ordinal = 0x6416a3f600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetFlags_GenOrdinal = 0x200be82ca523ab96lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetFlags_Ordinal = 0x3f23cc7600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetFlags_GenOrdinal = 0x713f375258671141lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetBuffer_Ordinal = 0x74c3097300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetBuffer_GenOrdinal = 0x4b93b8486666d951lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_OpenClient_Ordinal = 0x5ce2427f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_OpenClient_GenOrdinal = 0x78f040fe6a1ebb3lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOpenClientRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOpenClientResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ClrSetFeature_Ordinal = 0x5b74b23900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ClrSetFeature_GenOrdinal = 0x6367986e6053a15elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceClrSetFeatureRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceClrSetFeatureResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetWindowSize_Ordinal = 0x6b4f1d8300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetWindowSize_GenOrdinal = 0x747bed0460f5f9f7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetWindowSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetWindowSizeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_MakeActive_Ordinal = 0x9648f9700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_MakeActive_GenOrdinal = 0x2763944f30ee2a62lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceMakeActiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceMakeActiveResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ReadEvents_Ordinal = 0x65e3e0bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ReadEvents_GenOrdinal = 0xede96f3e3258f62lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadEventsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadEventsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetWindowSize_Ordinal = 0x3c0c556700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetWindowSize_GenOrdinal = 0x17d1cb37377e7928lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetWindowSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetWindowSizeResponseTable;
+
+} // namespace
+
+Device::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Device::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::ResultOf::Clone Device::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+Device::ResultOf::Clone Device::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+Device::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Device::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::UnownedResultOf::Clone Device::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+Device::UnownedResultOf::Clone Device::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError Device::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ Device::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Device::ResultOf::Close_Impl<Device::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::Close Device::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::Close Device::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::Close_Impl<Device::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Close Device::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Close Device::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::CloseResponse> Device::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Describe_Impl<Device::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::Describe Device::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::Describe Device::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::Describe_Impl<Device::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Describe Device::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Describe Device::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::DescribeResponse> Device::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Sync_Impl<Device::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::Sync Device::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::Sync Device::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::Sync_Impl<Device::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Sync Device::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Sync Device::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SyncResponse> Device::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetAttr_Impl<Device::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetAttr Device::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetAttr Device::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetAttr_Impl<Device::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetAttr Device::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetAttr Device::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetAttrResponse> Device::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetAttr_Impl<Device::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetAttr Device::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+Device::ResultOf::SetAttr Device::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+Device::UnownedResultOf::SetAttr_Impl<Device::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetAttr Device::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetAttr Device::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetAttrResponse> Device::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::NodeGetFlags_Impl<Device::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::NodeGetFlags Device::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::NodeGetFlags Device::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::NodeGetFlags_Impl<Device::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::NodeGetFlags Device::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::NodeGetFlags Device::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::NodeGetFlagsResponse> Device::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::NodeSetFlags_Impl<Device::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::NodeSetFlags Device::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Device::ResultOf::NodeSetFlags Device::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Device::UnownedResultOf::NodeSetFlags_Impl<Device::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::NodeSetFlags Device::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::NodeSetFlags Device::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::NodeSetFlagsResponse> Device::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Read_Impl<Device::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, uint64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_write_bytes);
+ _request.count = std::move(count);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Read(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::Read Device::SyncClient::Read(uint64_t count) {
+ return ResultOf::Read(::zx::unowned_channel(this->channel_), std::move(count));
+}
+
+Device::ResultOf::Read Device::Call::Read(::zx::unowned_channel _client_end, uint64_t count) {
+ return ResultOf::Read(std::move(_client_end), std::move(count));
+}
+
+template <>
+Device::UnownedResultOf::Read_Impl<Device::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_request_buffer.data());
+ _request.count = std::move(count);
+ _request_buffer.set_actual(sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::Read(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Read Device::SyncClient::Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Read Device::Call::Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(std::move(_client_end), std::move(_request_buffer), std::move(count), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ReadResponse> Device::InPlace::Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::ReadRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ReadResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadRequest, ReadResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ReadResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ReadAt_Impl<Device::ReadAtResponse>::ReadAt_Impl(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAtRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadAtRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAtRequest*>(_write_bytes);
+ _request.count = std::move(count);
+ _request.offset = std::move(offset);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadAtRequest));
+ ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ReadAt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::ReadAt Device::SyncClient::ReadAt(uint64_t count, uint64_t offset) {
+ return ResultOf::ReadAt(::zx::unowned_channel(this->channel_), std::move(count), std::move(offset));
+}
+
+Device::ResultOf::ReadAt Device::Call::ReadAt(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset) {
+ return ResultOf::ReadAt(std::move(_client_end), std::move(count), std::move(offset));
+}
+
+template <>
+Device::UnownedResultOf::ReadAt_Impl<Device::ReadAtResponse>::ReadAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadAtRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadAtResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadAtRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAtRequest*>(_request_buffer.data());
+ _request.count = std::move(count);
+ _request.offset = std::move(offset);
+ _request_buffer.set_actual(sizeof(ReadAtRequest));
+ ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::ReadAt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::ReadAt Device::SyncClient::ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::ReadAt Device::Call::ReadAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAt(std::move(_client_end), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ReadAtResponse> Device::InPlace::ReadAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::ReadAtRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ReadAtResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadAtRequest, ReadAtResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ReadAtResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Write_Impl<Device::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::Write(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::Write Device::SyncClient::Write(::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Write(::zx::unowned_channel(this->channel_), std::move(data));
+}
+
+Device::ResultOf::Write Device::Call::Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Write(std::move(_client_end), std::move(data));
+}
+
+template <>
+Device::UnownedResultOf::Write_Impl<Device::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::Write(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Write Device::SyncClient::Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Write Device::Call::Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::WriteResponse> Device::InPlace::Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::WriteRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::WriteResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::WriteResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::WriteAt_Impl<Device::WriteAtResponse>::WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteAtRequest _request = {};
+ _request.data = std::move(data);
+ _request.offset = std::move(offset);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::WriteAt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::WriteAt Device::SyncClient::WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ return ResultOf::WriteAt(::zx::unowned_channel(this->channel_), std::move(data), std::move(offset));
+}
+
+Device::ResultOf::WriteAt Device::Call::WriteAt(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ return ResultOf::WriteAt(std::move(_client_end), std::move(data), std::move(offset));
+}
+
+template <>
+Device::UnownedResultOf::WriteAt_Impl<Device::WriteAtResponse>::WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteAtRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteAtResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteAtRequest _request = {};
+ _request.data = std::move(data);
+ _request.offset = std::move(offset);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::WriteAt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::WriteAt Device::SyncClient::WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::WriteAt Device::Call::WriteAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAt(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::WriteAtResponse> Device::InPlace::WriteAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::WriteAtRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::WriteAtResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteAtRequest, WriteAtResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::WriteAtResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Seek_Impl<Device::SeekResponse>::Seek_Impl(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SeekRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SeekRequest*>(_write_bytes);
+ _request.offset = std::move(offset);
+ _request.start = std::move(start);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SeekRequest));
+ ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Seek(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::Seek Device::SyncClient::Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
+ return ResultOf::Seek(::zx::unowned_channel(this->channel_), std::move(offset), std::move(start));
+}
+
+Device::ResultOf::Seek Device::Call::Seek(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
+ return ResultOf::Seek(std::move(_client_end), std::move(offset), std::move(start));
+}
+
+template <>
+Device::UnownedResultOf::Seek_Impl<Device::SeekResponse>::Seek_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SeekRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SeekResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SeekRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SeekRequest*>(_request_buffer.data());
+ _request.offset = std::move(offset);
+ _request.start = std::move(start);
+ _request_buffer.set_actual(sizeof(SeekRequest));
+ ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::Seek(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Seek Device::SyncClient::Seek(::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Seek(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(offset), std::move(start), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Seek Device::Call::Seek(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Seek(std::move(_client_end), std::move(_request_buffer), std::move(offset), std::move(start), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SeekResponse> Device::InPlace::Seek(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SeekRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SeekResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SeekRequest, SeekResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SeekResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Truncate_Impl<Device::TruncateResponse>::Truncate_Impl(::zx::unowned_channel _client_end, uint64_t length) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TruncateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, TruncateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<TruncateRequest*>(_write_bytes);
+ _request.length = std::move(length);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(TruncateRequest));
+ ::fidl::DecodedMessage<TruncateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Truncate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::Truncate Device::SyncClient::Truncate(uint64_t length) {
+ return ResultOf::Truncate(::zx::unowned_channel(this->channel_), std::move(length));
+}
+
+Device::ResultOf::Truncate Device::Call::Truncate(::zx::unowned_channel _client_end, uint64_t length) {
+ return ResultOf::Truncate(std::move(_client_end), std::move(length));
+}
+
+template <>
+Device::UnownedResultOf::Truncate_Impl<Device::TruncateResponse>::Truncate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < TruncateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<TruncateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, TruncateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<TruncateRequest*>(_request_buffer.data());
+ _request.length = std::move(length);
+ _request_buffer.set_actual(sizeof(TruncateRequest));
+ ::fidl::DecodedMessage<TruncateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::Truncate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Truncate Device::SyncClient::Truncate(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Truncate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(length), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Truncate Device::Call::Truncate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Truncate(std::move(_client_end), std::move(_request_buffer), std::move(length), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::TruncateResponse> Device::InPlace::Truncate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TruncateRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::TruncateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::TruncateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<TruncateRequest, TruncateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::TruncateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetFlags_Impl<Device::GetFlagsResponse>::GetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFlagsRequest));
+ ::fidl::DecodedMessage<GetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetFlags Device::SyncClient::GetFlags() {
+ return ResultOf::GetFlags(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetFlags Device::Call::GetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFlags(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetFlags_Impl<Device::GetFlagsResponse>::GetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFlagsRequest));
+ ::fidl::DecodedMessage<GetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetFlags Device::SyncClient::GetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetFlags Device::Call::GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetFlagsResponse> Device::InPlace::GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFlagsRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFlagsRequest, GetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetFlags_Impl<Device::SetFlagsResponse>::SetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetFlagsRequest));
+ ::fidl::DecodedMessage<SetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetFlags Device::SyncClient::SetFlags(uint32_t flags) {
+ return ResultOf::SetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Device::ResultOf::SetFlags Device::Call::SetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::SetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Device::UnownedResultOf::SetFlags_Impl<Device::SetFlagsResponse>::SetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(SetFlagsRequest));
+ ::fidl::DecodedMessage<SetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetFlags Device::SyncClient::SetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetFlags Device::Call::SetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetFlagsResponse> Device::InPlace::SetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetFlagsRequest, SetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetBuffer_Impl<Device::GetBufferResponse>::GetBuffer_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBufferRequest));
+ ::fidl::DecodedMessage<GetBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetBuffer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetBuffer Device::SyncClient::GetBuffer(uint32_t flags) {
+ return ResultOf::GetBuffer(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Device::ResultOf::GetBuffer Device::Call::GetBuffer(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::GetBuffer(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Device::UnownedResultOf::GetBuffer_Impl<Device::GetBufferResponse>::GetBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetBufferRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetBufferResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(GetBufferRequest));
+ ::fidl::DecodedMessage<GetBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetBuffer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetBuffer Device::SyncClient::GetBuffer(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetBuffer Device::Call::GetBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBuffer(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetBufferResponse> Device::InPlace::GetBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetBufferResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetBufferRequest, GetBufferResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetBufferResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::OpenClient_Impl<Device::OpenClientResponse>::OpenClient_Impl(::zx::unowned_channel _client_end, uint32_t id, ::zx::channel client) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenClientRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, OpenClientRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OpenClientRequest*>(_write_bytes);
+ _request.id = std::move(id);
+ _request.client = std::move(client);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OpenClientRequest));
+ ::fidl::DecodedMessage<OpenClientRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::OpenClient(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::OpenClient Device::SyncClient::OpenClient(uint32_t id, ::zx::channel client) {
+ return ResultOf::OpenClient(::zx::unowned_channel(this->channel_), std::move(id), std::move(client));
+}
+
+Device::ResultOf::OpenClient Device::Call::OpenClient(::zx::unowned_channel _client_end, uint32_t id, ::zx::channel client) {
+ return ResultOf::OpenClient(std::move(_client_end), std::move(id), std::move(client));
+}
+
+template <>
+Device::UnownedResultOf::OpenClient_Impl<Device::OpenClientResponse>::OpenClient_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, ::zx::channel client, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < OpenClientRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<OpenClientResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, OpenClientRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OpenClientRequest*>(_request_buffer.data());
+ _request.id = std::move(id);
+ _request.client = std::move(client);
+ _request_buffer.set_actual(sizeof(OpenClientRequest));
+ ::fidl::DecodedMessage<OpenClientRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::OpenClient(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::OpenClient Device::SyncClient::OpenClient(::fidl::BytePart _request_buffer, uint32_t id, ::zx::channel client, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenClient(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(id), std::move(client), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::OpenClient Device::Call::OpenClient(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, ::zx::channel client, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenClient(std::move(_client_end), std::move(_request_buffer), std::move(id), std::move(client), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::OpenClientResponse> Device::InPlace::OpenClient(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenClientRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::OpenClientRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::OpenClientResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<OpenClientRequest, OpenClientResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::OpenClientResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ClrSetFeature_Impl<Device::ClrSetFeatureResponse>::ClrSetFeature_Impl(::zx::unowned_channel _client_end, uint32_t clr, uint32_t set) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ClrSetFeatureRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ClrSetFeatureRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ClrSetFeatureRequest*>(_write_bytes);
+ _request.clr = std::move(clr);
+ _request.set = std::move(set);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ClrSetFeatureRequest));
+ ::fidl::DecodedMessage<ClrSetFeatureRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ClrSetFeature(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::ClrSetFeature Device::SyncClient::ClrSetFeature(uint32_t clr, uint32_t set) {
+ return ResultOf::ClrSetFeature(::zx::unowned_channel(this->channel_), std::move(clr), std::move(set));
+}
+
+Device::ResultOf::ClrSetFeature Device::Call::ClrSetFeature(::zx::unowned_channel _client_end, uint32_t clr, uint32_t set) {
+ return ResultOf::ClrSetFeature(std::move(_client_end), std::move(clr), std::move(set));
+}
+
+template <>
+Device::UnownedResultOf::ClrSetFeature_Impl<Device::ClrSetFeatureResponse>::ClrSetFeature_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ClrSetFeatureRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ClrSetFeatureResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ClrSetFeatureRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ClrSetFeatureRequest*>(_request_buffer.data());
+ _request.clr = std::move(clr);
+ _request.set = std::move(set);
+ _request_buffer.set_actual(sizeof(ClrSetFeatureRequest));
+ ::fidl::DecodedMessage<ClrSetFeatureRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::ClrSetFeature(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::ClrSetFeature Device::SyncClient::ClrSetFeature(::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ClrSetFeature(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(clr), std::move(set), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::ClrSetFeature Device::Call::ClrSetFeature(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ClrSetFeature(std::move(_client_end), std::move(_request_buffer), std::move(clr), std::move(set), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ClrSetFeatureResponse> Device::InPlace::ClrSetFeature(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ClrSetFeatureRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::ClrSetFeatureRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ClrSetFeatureResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ClrSetFeatureRequest, ClrSetFeatureResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ClrSetFeatureResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetWindowSize_Impl<Device::GetWindowSizeResponse>::GetWindowSize_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetWindowSizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetWindowSizeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetWindowSizeRequest));
+ ::fidl::DecodedMessage<GetWindowSizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetWindowSize(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetWindowSize Device::SyncClient::GetWindowSize() {
+ return ResultOf::GetWindowSize(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetWindowSize Device::Call::GetWindowSize(::zx::unowned_channel _client_end) {
+ return ResultOf::GetWindowSize(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetWindowSize_Impl<Device::GetWindowSizeResponse>::GetWindowSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetWindowSizeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetWindowSizeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetWindowSizeRequest));
+ ::fidl::DecodedMessage<GetWindowSizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetWindowSize(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetWindowSize Device::SyncClient::GetWindowSize(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetWindowSize(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetWindowSize Device::Call::GetWindowSize(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetWindowSize(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetWindowSizeResponse> Device::InPlace::GetWindowSize(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetWindowSizeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetWindowSizeRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetWindowSizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetWindowSizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetWindowSizeRequest, GetWindowSizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetWindowSizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::MakeActive_Impl<Device::MakeActiveResponse>::MakeActive_Impl(::zx::unowned_channel _client_end, uint32_t client_pty_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MakeActiveRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, MakeActiveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<MakeActiveRequest*>(_write_bytes);
+ _request.client_pty_id = std::move(client_pty_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(MakeActiveRequest));
+ ::fidl::DecodedMessage<MakeActiveRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::MakeActive(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::MakeActive Device::SyncClient::MakeActive(uint32_t client_pty_id) {
+ return ResultOf::MakeActive(::zx::unowned_channel(this->channel_), std::move(client_pty_id));
+}
+
+Device::ResultOf::MakeActive Device::Call::MakeActive(::zx::unowned_channel _client_end, uint32_t client_pty_id) {
+ return ResultOf::MakeActive(std::move(_client_end), std::move(client_pty_id));
+}
+
+template <>
+Device::UnownedResultOf::MakeActive_Impl<Device::MakeActiveResponse>::MakeActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t client_pty_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < MakeActiveRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<MakeActiveResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, MakeActiveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<MakeActiveRequest*>(_request_buffer.data());
+ _request.client_pty_id = std::move(client_pty_id);
+ _request_buffer.set_actual(sizeof(MakeActiveRequest));
+ ::fidl::DecodedMessage<MakeActiveRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::MakeActive(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::MakeActive Device::SyncClient::MakeActive(::fidl::BytePart _request_buffer, uint32_t client_pty_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::MakeActive(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(client_pty_id), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::MakeActive Device::Call::MakeActive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t client_pty_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::MakeActive(std::move(_client_end), std::move(_request_buffer), std::move(client_pty_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::MakeActiveResponse> Device::InPlace::MakeActive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MakeActiveRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::MakeActiveRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::MakeActiveResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<MakeActiveRequest, MakeActiveResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::MakeActiveResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ReadEvents_Impl<Device::ReadEventsResponse>::ReadEvents_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadEventsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadEventsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadEventsRequest));
+ ::fidl::DecodedMessage<ReadEventsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ReadEvents(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::ReadEvents Device::SyncClient::ReadEvents() {
+ return ResultOf::ReadEvents(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::ReadEvents Device::Call::ReadEvents(::zx::unowned_channel _client_end) {
+ return ResultOf::ReadEvents(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::ReadEvents_Impl<Device::ReadEventsResponse>::ReadEvents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ReadEventsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ReadEventsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ReadEventsRequest));
+ ::fidl::DecodedMessage<ReadEventsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::ReadEvents(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::ReadEvents Device::SyncClient::ReadEvents(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadEvents(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::ReadEvents Device::Call::ReadEvents(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadEvents(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ReadEventsResponse> Device::InPlace::ReadEvents(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ReadEventsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ReadEventsRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::ReadEventsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ReadEventsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadEventsRequest, ReadEventsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ReadEventsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetWindowSize_Impl<Device::SetWindowSizeResponse>::SetWindowSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::pty::WindowSize size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetWindowSizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetWindowSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetWindowSizeRequest*>(_write_bytes);
+ _request.size = std::move(size);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetWindowSizeRequest));
+ ::fidl::DecodedMessage<SetWindowSizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetWindowSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetWindowSize Device::SyncClient::SetWindowSize(::llcpp::fuchsia::hardware::pty::WindowSize size) {
+ return ResultOf::SetWindowSize(::zx::unowned_channel(this->channel_), std::move(size));
+}
+
+Device::ResultOf::SetWindowSize Device::Call::SetWindowSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::pty::WindowSize size) {
+ return ResultOf::SetWindowSize(std::move(_client_end), std::move(size));
+}
+
+template <>
+Device::UnownedResultOf::SetWindowSize_Impl<Device::SetWindowSizeResponse>::SetWindowSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetWindowSizeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetWindowSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetWindowSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetWindowSizeRequest*>(_request_buffer.data());
+ _request.size = std::move(size);
+ _request_buffer.set_actual(sizeof(SetWindowSizeRequest));
+ ::fidl::DecodedMessage<SetWindowSizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetWindowSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetWindowSize Device::SyncClient::SetWindowSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetWindowSize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(size), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetWindowSize Device::Call::SetWindowSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetWindowSize(std::move(_client_end), std::move(_request_buffer), std::move(size), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetWindowSizeResponse> Device::InPlace::SetWindowSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetWindowSizeRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetWindowSizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetWindowSizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetWindowSizeRequest, SetWindowSizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetWindowSizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Device::SyncClient::HandleEvents(Device::EventHandlers handlers) {
+ return Device::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Device::Call::HandleEvents(::zx::unowned_channel client_end, Device::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_OnOpen_Ordinal:
+ case kDevice_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_Clone_Ordinal:
+ case kDevice_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Close_Ordinal:
+ case kDevice_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Describe_Ordinal:
+ case kDevice_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Sync_Ordinal:
+ case kDevice_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetAttr_Ordinal:
+ case kDevice_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetAttr_Ordinal:
+ case kDevice_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_NodeGetFlags_Ordinal:
+ case kDevice_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_NodeSetFlags_Ordinal:
+ case kDevice_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Read_Ordinal:
+ case kDevice_Read_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Read(std::move(message->count),
+ Interface::ReadCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ReadAt_Ordinal:
+ case kDevice_ReadAt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadAtRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReadAt(std::move(message->count), std::move(message->offset),
+ Interface::ReadAtCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Write_Ordinal:
+ case kDevice_Write_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Write(std::move(message->data),
+ Interface::WriteCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_WriteAt_Ordinal:
+ case kDevice_WriteAt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteAtRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteAt(std::move(message->data), std::move(message->offset),
+ Interface::WriteAtCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Seek_Ordinal:
+ case kDevice_Seek_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SeekRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Seek(std::move(message->offset), std::move(message->start),
+ Interface::SeekCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Truncate_Ordinal:
+ case kDevice_Truncate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<TruncateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Truncate(std::move(message->length),
+ Interface::TruncateCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetFlags_Ordinal:
+ case kDevice_GetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFlags(
+ Interface::GetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetFlags_Ordinal:
+ case kDevice_SetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetFlags(std::move(message->flags),
+ Interface::SetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetBuffer_Ordinal:
+ case kDevice_GetBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetBuffer(std::move(message->flags),
+ Interface::GetBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_OpenClient_Ordinal:
+ case kDevice_OpenClient_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenClientRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OpenClient(std::move(message->id), std::move(message->client),
+ Interface::OpenClientCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ClrSetFeature_Ordinal:
+ case kDevice_ClrSetFeature_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ClrSetFeatureRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ClrSetFeature(std::move(message->clr), std::move(message->set),
+ Interface::ClrSetFeatureCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetWindowSize_Ordinal:
+ case kDevice_GetWindowSize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetWindowSizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetWindowSize(
+ Interface::GetWindowSizeCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_MakeActive_Ordinal:
+ case kDevice_MakeActive_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<MakeActiveRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->MakeActive(std::move(message->client_pty_id),
+ Interface::MakeActiveCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ReadEvents_Ordinal:
+ case kDevice_ReadEvents_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadEventsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ReadEvents(
+ Interface::ReadEventsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetWindowSize_Ordinal:
+ case kDevice_SetWindowSize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetWindowSizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetWindowSize(std::move(message->size),
+ Interface::SetWindowSizeCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ Device::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ Device::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Device::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Device::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Device::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ Device::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Device::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ Device::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Device::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ Device::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Device::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Device::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ Device::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ Device::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ Device::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ Device::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ReadCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadResponse _response = {};
+ Device::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::ReadCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data) {
+ if (_buffer.capacity() < ReadResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadResponse _response = {};
+ Device::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::ReadCompleterBase::Reply(::fidl::DecodedMessage<ReadResponse> params) {
+ Device::SetTransactionHeaderFor::ReadResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ReadAtCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAtResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadAtResponse _response = {};
+ Device::SetTransactionHeaderFor::ReadAtResponse(
+ ::fidl::DecodedMessage<ReadAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAtResponse::PrimarySize,
+ ReadAtResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::ReadAtCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data) {
+ if (_buffer.capacity() < ReadAtResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadAtResponse _response = {};
+ Device::SetTransactionHeaderFor::ReadAtResponse(
+ ::fidl::DecodedMessage<ReadAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAtResponse::PrimarySize,
+ ReadAtResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::ReadAtCompleterBase::Reply(::fidl::DecodedMessage<ReadAtResponse> params) {
+ Device::SetTransactionHeaderFor::ReadAtResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::WriteCompleterBase::Reply(int32_t s, uint64_t actual) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.actual = std::move(actual);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::WriteCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual) {
+ if (_buffer.capacity() < WriteResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.actual = std::move(actual);
+ _buffer.set_actual(sizeof(WriteResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::WriteCompleterBase::Reply(::fidl::DecodedMessage<WriteResponse> params) {
+ Device::SetTransactionHeaderFor::WriteResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::WriteAtCompleterBase::Reply(int32_t s, uint64_t actual) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteAtResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::WriteAtResponse(
+ ::fidl::DecodedMessage<WriteAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAtResponse::PrimarySize,
+ WriteAtResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.actual = std::move(actual);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteAtResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteAtResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::WriteAtCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual) {
+ if (_buffer.capacity() < WriteAtResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteAtResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::WriteAtResponse(
+ ::fidl::DecodedMessage<WriteAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAtResponse::PrimarySize,
+ WriteAtResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.actual = std::move(actual);
+ _buffer.set_actual(sizeof(WriteAtResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteAtResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::WriteAtCompleterBase::Reply(::fidl::DecodedMessage<WriteAtResponse> params) {
+ Device::SetTransactionHeaderFor::WriteAtResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SeekCompleterBase::Reply(int32_t s, uint64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SeekResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SeekResponse(
+ ::fidl::DecodedMessage<SeekResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SeekResponse::PrimarySize,
+ SeekResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.offset = std::move(offset);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SeekResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SeekResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SeekCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t offset) {
+ if (_buffer.capacity() < SeekResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SeekResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SeekResponse(
+ ::fidl::DecodedMessage<SeekResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SeekResponse::PrimarySize,
+ SeekResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.offset = std::move(offset);
+ _buffer.set_actual(sizeof(SeekResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SeekResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SeekCompleterBase::Reply(::fidl::DecodedMessage<SeekResponse> params) {
+ Device::SetTransactionHeaderFor::SeekResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::TruncateCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TruncateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<TruncateResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::TruncateResponse(
+ ::fidl::DecodedMessage<TruncateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TruncateResponse::PrimarySize,
+ TruncateResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(TruncateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<TruncateResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::TruncateCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < TruncateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<TruncateResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::TruncateResponse(
+ ::fidl::DecodedMessage<TruncateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TruncateResponse::PrimarySize,
+ TruncateResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(TruncateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<TruncateResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::TruncateCompleterBase::Reply(::fidl::DecodedMessage<TruncateResponse> params) {
+ Device::SetTransactionHeaderFor::TruncateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetFlagsResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetFlagsResponse(
+ ::fidl::DecodedMessage<GetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFlagsResponse::PrimarySize,
+ GetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < GetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetFlagsResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetFlagsResponse(
+ ::fidl::DecodedMessage<GetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFlagsResponse::PrimarySize,
+ GetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(GetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFlagsResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetFlagsCompleterBase::Reply(::fidl::DecodedMessage<GetFlagsResponse> params) {
+ Device::SetTransactionHeaderFor::GetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetFlagsResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetFlagsResponse(
+ ::fidl::DecodedMessage<SetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetFlagsResponse::PrimarySize,
+ SetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetFlagsResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetFlagsResponse(
+ ::fidl::DecodedMessage<SetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetFlagsResponse::PrimarySize,
+ SetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetFlagsResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetFlagsCompleterBase::Reply(::fidl::DecodedMessage<SetFlagsResponse> params) {
+ Device::SetTransactionHeaderFor::SetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetBufferCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetBufferResponse _response = {};
+ Device::SetTransactionHeaderFor::GetBufferResponse(
+ ::fidl::DecodedMessage<GetBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferResponse::PrimarySize,
+ GetBufferResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.buffer = std::move(buffer);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetBufferCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer) {
+ if (_buffer.capacity() < GetBufferResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetBufferResponse _response = {};
+ Device::SetTransactionHeaderFor::GetBufferResponse(
+ ::fidl::DecodedMessage<GetBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferResponse::PrimarySize,
+ GetBufferResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.buffer = std::move(buffer);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetBufferCompleterBase::Reply(::fidl::DecodedMessage<GetBufferResponse> params) {
+ Device::SetTransactionHeaderFor::GetBufferResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::OpenClientCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenClientResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<OpenClientResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::OpenClientResponse(
+ ::fidl::DecodedMessage<OpenClientResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenClientResponse::PrimarySize,
+ OpenClientResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(OpenClientResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<OpenClientResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::OpenClientCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < OpenClientResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<OpenClientResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::OpenClientResponse(
+ ::fidl::DecodedMessage<OpenClientResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenClientResponse::PrimarySize,
+ OpenClientResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(OpenClientResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<OpenClientResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::OpenClientCompleterBase::Reply(::fidl::DecodedMessage<OpenClientResponse> params) {
+ Device::SetTransactionHeaderFor::OpenClientResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ClrSetFeatureCompleterBase::Reply(int32_t status, uint32_t features) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ClrSetFeatureResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ClrSetFeatureResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ClrSetFeatureResponse(
+ ::fidl::DecodedMessage<ClrSetFeatureResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ClrSetFeatureResponse::PrimarySize,
+ ClrSetFeatureResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.features = std::move(features);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ClrSetFeatureResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ClrSetFeatureResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::ClrSetFeatureCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint32_t features) {
+ if (_buffer.capacity() < ClrSetFeatureResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ClrSetFeatureResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::ClrSetFeatureResponse(
+ ::fidl::DecodedMessage<ClrSetFeatureResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ClrSetFeatureResponse::PrimarySize,
+ ClrSetFeatureResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.features = std::move(features);
+ _buffer.set_actual(sizeof(ClrSetFeatureResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ClrSetFeatureResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::ClrSetFeatureCompleterBase::Reply(::fidl::DecodedMessage<ClrSetFeatureResponse> params) {
+ Device::SetTransactionHeaderFor::ClrSetFeatureResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetWindowSizeCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::pty::WindowSize size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetWindowSizeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetWindowSizeResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetWindowSizeResponse(
+ ::fidl::DecodedMessage<GetWindowSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetWindowSizeResponse::PrimarySize,
+ GetWindowSizeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.size = std::move(size);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetWindowSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetWindowSizeResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetWindowSizeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::pty::WindowSize size) {
+ if (_buffer.capacity() < GetWindowSizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetWindowSizeResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetWindowSizeResponse(
+ ::fidl::DecodedMessage<GetWindowSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetWindowSizeResponse::PrimarySize,
+ GetWindowSizeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.size = std::move(size);
+ _buffer.set_actual(sizeof(GetWindowSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetWindowSizeResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetWindowSizeCompleterBase::Reply(::fidl::DecodedMessage<GetWindowSizeResponse> params) {
+ Device::SetTransactionHeaderFor::GetWindowSizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::MakeActiveCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MakeActiveResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<MakeActiveResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::MakeActiveResponse(
+ ::fidl::DecodedMessage<MakeActiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MakeActiveResponse::PrimarySize,
+ MakeActiveResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(MakeActiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<MakeActiveResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::MakeActiveCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < MakeActiveResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<MakeActiveResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::MakeActiveResponse(
+ ::fidl::DecodedMessage<MakeActiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MakeActiveResponse::PrimarySize,
+ MakeActiveResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(MakeActiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<MakeActiveResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::MakeActiveCompleterBase::Reply(::fidl::DecodedMessage<MakeActiveResponse> params) {
+ Device::SetTransactionHeaderFor::MakeActiveResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ReadEventsCompleterBase::Reply(int32_t status, uint32_t events) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadEventsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ReadEventsResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ReadEventsResponse(
+ ::fidl::DecodedMessage<ReadEventsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadEventsResponse::PrimarySize,
+ ReadEventsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.events = std::move(events);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadEventsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ReadEventsResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::ReadEventsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint32_t events) {
+ if (_buffer.capacity() < ReadEventsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ReadEventsResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::ReadEventsResponse(
+ ::fidl::DecodedMessage<ReadEventsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadEventsResponse::PrimarySize,
+ ReadEventsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.events = std::move(events);
+ _buffer.set_actual(sizeof(ReadEventsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ReadEventsResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::ReadEventsCompleterBase::Reply(::fidl::DecodedMessage<ReadEventsResponse> params) {
+ Device::SetTransactionHeaderFor::ReadEventsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetWindowSizeCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetWindowSizeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetWindowSizeResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetWindowSizeResponse(
+ ::fidl::DecodedMessage<SetWindowSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetWindowSizeResponse::PrimarySize,
+ SetWindowSizeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetWindowSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetWindowSizeResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetWindowSizeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetWindowSizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetWindowSizeResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetWindowSizeResponse(
+ ::fidl::DecodedMessage<SetWindowSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetWindowSizeResponse::PrimarySize,
+ SetWindowSizeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetWindowSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetWindowSizeResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetWindowSizeCompleterBase::Reply(::fidl::DecodedMessage<SetWindowSizeResponse> params) {
+ Device::SetTransactionHeaderFor::SetWindowSizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<Device::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Device::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<Device::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Device::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Device::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<Device::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Device::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Device::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<Device::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<Device::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<Device::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<Device::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<Device::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<Device::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<Device::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<Device::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ReadRequest(const ::fidl::DecodedMessage<Device::ReadRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ReadResponse(const ::fidl::DecodedMessage<Device::ReadResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ReadAtRequest(const ::fidl::DecodedMessage<Device::ReadAtRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ReadAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ReadAtResponse(const ::fidl::DecodedMessage<Device::ReadAtResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ReadAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::WriteRequest(const ::fidl::DecodedMessage<Device::WriteRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::WriteResponse(const ::fidl::DecodedMessage<Device::WriteResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::WriteAtRequest(const ::fidl::DecodedMessage<Device::WriteAtRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_WriteAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::WriteAtResponse(const ::fidl::DecodedMessage<Device::WriteAtResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_WriteAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SeekRequest(const ::fidl::DecodedMessage<Device::SeekRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Seek_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SeekResponse(const ::fidl::DecodedMessage<Device::SeekResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Seek_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::TruncateRequest(const ::fidl::DecodedMessage<Device::TruncateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Truncate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::TruncateResponse(const ::fidl::DecodedMessage<Device::TruncateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Truncate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetFlagsRequest(const ::fidl::DecodedMessage<Device::GetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetFlagsResponse(const ::fidl::DecodedMessage<Device::GetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetFlagsRequest(const ::fidl::DecodedMessage<Device::SetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetFlagsResponse(const ::fidl::DecodedMessage<Device::SetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetBufferRequest(const ::fidl::DecodedMessage<Device::GetBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetBufferResponse(const ::fidl::DecodedMessage<Device::GetBufferResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::OpenClientRequest(const ::fidl::DecodedMessage<Device::OpenClientRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_OpenClient_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::OpenClientResponse(const ::fidl::DecodedMessage<Device::OpenClientResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_OpenClient_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ClrSetFeatureRequest(const ::fidl::DecodedMessage<Device::ClrSetFeatureRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ClrSetFeature_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ClrSetFeatureResponse(const ::fidl::DecodedMessage<Device::ClrSetFeatureResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ClrSetFeature_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetWindowSizeRequest(const ::fidl::DecodedMessage<Device::GetWindowSizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetWindowSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetWindowSizeResponse(const ::fidl::DecodedMessage<Device::GetWindowSizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetWindowSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::MakeActiveRequest(const ::fidl::DecodedMessage<Device::MakeActiveRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_MakeActive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::MakeActiveResponse(const ::fidl::DecodedMessage<Device::MakeActiveResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_MakeActive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ReadEventsRequest(const ::fidl::DecodedMessage<Device::ReadEventsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ReadEvents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ReadEventsResponse(const ::fidl::DecodedMessage<Device::ReadEventsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ReadEvents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetWindowSizeRequest(const ::fidl::DecodedMessage<Device::SetWindowSizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetWindowSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetWindowSizeResponse(const ::fidl::DecodedMessage<Device::SetWindowSizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetWindowSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace pty
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-pty/gen/llcpp/include/fuchsia/hardware/pty/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-pty/gen/llcpp/include/fuchsia/hardware/pty/llcpp/fidl.h
new file mode 100644
index 0000000..abcece1
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-pty/gen/llcpp/include/fuchsia/hardware/pty/llcpp/fidl.h
@@ -0,0 +1,3245 @@
+// 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 <zircon/fidl.h>
+
+#include <fuchsia/io/llcpp/fidl.h>
+#include <fuchsia/mem/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace pty {
+
+struct WindowSize;
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_WindowSizeTable;
+
+struct WindowSize {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_WindowSizeTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t width = {};
+
+ uint32_t height = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadAtResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceWriteAtResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSeekRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSeekResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceTruncateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceTruncateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOpenClientRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceOpenClientResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceClrSetFeatureRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceClrSetFeatureResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetWindowSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceGetWindowSizeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceMakeActiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceMakeActiveResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadEventsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceReadEventsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetWindowSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_pty_DeviceSetWindowSizeResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.hardware.pty.Device";
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct ReadResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceReadResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 ReadRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceReadRequestTable;
+ 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 = ReadResponse;
+ };
+
+ struct ReadAtResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceReadAtResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 ReadAtRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t count;
+ uint64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceReadAtRequestTable;
+ 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 = ReadAtResponse;
+ };
+
+ struct WriteResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint64_t actual;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceWriteResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 WriteRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceWriteRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = WriteResponse;
+ };
+
+ struct WriteAtResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint64_t actual;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceWriteAtResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 WriteAtRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> data;
+ uint64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceWriteAtRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = WriteAtResponse;
+ };
+
+ struct SeekResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSeekResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 SeekRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int64_t offset;
+ ::llcpp::fuchsia::io::SeekOrigin start;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSeekRequestTable;
+ 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 = SeekResponse;
+ };
+
+ struct TruncateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceTruncateResponseTable;
+ 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 TruncateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t length;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceTruncateRequestTable;
+ 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 = TruncateResponse;
+ };
+
+ struct GetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceGetFlagsResponseTable;
+ 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 GetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSetFlagsResponseTable;
+ 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 SetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSetFlagsRequestTable;
+ 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 = SetFlagsResponse;
+ };
+
+ struct GetBufferResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::mem::Buffer* buffer;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceGetBufferResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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;
+ };
+ struct GetBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceGetBufferRequestTable;
+ 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 = GetBufferResponse;
+ };
+
+ struct OpenClientResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceOpenClientResponseTable;
+ 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 OpenClientRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t id;
+ ::zx::channel client;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceOpenClientRequestTable;
+ 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 = OpenClientResponse;
+ };
+
+ struct ClrSetFeatureResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint32_t features;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceClrSetFeatureResponseTable;
+ 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 ClrSetFeatureRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t clr;
+ uint32_t set;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceClrSetFeatureRequestTable;
+ 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 = ClrSetFeatureResponse;
+ };
+
+ struct GetWindowSizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::hardware::pty::WindowSize size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceGetWindowSizeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 GetWindowSizeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct MakeActiveResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceMakeActiveResponseTable;
+ 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 MakeActiveRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t client_pty_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceMakeActiveRequestTable;
+ 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 = MakeActiveResponse;
+ };
+
+ struct ReadEventsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint32_t events;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceReadEventsResponseTable;
+ 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 ReadEventsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetWindowSizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSetWindowSizeResponseTable;
+ 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 SetWindowSizeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::pty::WindowSize size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_pty_DeviceSetWindowSizeRequestTable;
+ 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 = SetWindowSizeResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Read_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, uint64_t count);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 ReadAt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadAt_Impl(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset);
+ ~ReadAt_Impl() = default;
+ ReadAt_Impl(ReadAt_Impl&& other) = default;
+ ReadAt_Impl& operator=(ReadAt_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 Write_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 WriteAt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset);
+ ~WriteAt_Impl() = default;
+ WriteAt_Impl(WriteAt_Impl&& other) = default;
+ WriteAt_Impl& operator=(WriteAt_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 Seek_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Seek_Impl(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);
+ ~Seek_Impl() = default;
+ Seek_Impl(Seek_Impl&& other) = default;
+ Seek_Impl& operator=(Seek_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 Truncate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Truncate_Impl(::zx::unowned_channel _client_end, uint64_t length);
+ ~Truncate_Impl() = default;
+ Truncate_Impl(Truncate_Impl&& other) = default;
+ Truncate_Impl& operator=(Truncate_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 GetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetFlags_Impl(::zx::unowned_channel _client_end);
+ ~GetFlags_Impl() = default;
+ GetFlags_Impl(GetFlags_Impl&& other) = default;
+ GetFlags_Impl& operator=(GetFlags_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 SetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~SetFlags_Impl() = default;
+ SetFlags_Impl(SetFlags_Impl&& other) = default;
+ SetFlags_Impl& operator=(SetFlags_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 GetBuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetBuffer_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~GetBuffer_Impl() = default;
+ GetBuffer_Impl(GetBuffer_Impl&& other) = default;
+ GetBuffer_Impl& operator=(GetBuffer_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 OpenClient_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ OpenClient_Impl(::zx::unowned_channel _client_end, uint32_t id, ::zx::channel client);
+ ~OpenClient_Impl() = default;
+ OpenClient_Impl(OpenClient_Impl&& other) = default;
+ OpenClient_Impl& operator=(OpenClient_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 ClrSetFeature_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ClrSetFeature_Impl(::zx::unowned_channel _client_end, uint32_t clr, uint32_t set);
+ ~ClrSetFeature_Impl() = default;
+ ClrSetFeature_Impl(ClrSetFeature_Impl&& other) = default;
+ ClrSetFeature_Impl& operator=(ClrSetFeature_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 GetWindowSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetWindowSize_Impl(::zx::unowned_channel _client_end);
+ ~GetWindowSize_Impl() = default;
+ GetWindowSize_Impl(GetWindowSize_Impl&& other) = default;
+ GetWindowSize_Impl& operator=(GetWindowSize_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 MakeActive_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ MakeActive_Impl(::zx::unowned_channel _client_end, uint32_t client_pty_id);
+ ~MakeActive_Impl() = default;
+ MakeActive_Impl(MakeActive_Impl&& other) = default;
+ MakeActive_Impl& operator=(MakeActive_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 ReadEvents_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadEvents_Impl(::zx::unowned_channel _client_end);
+ ~ReadEvents_Impl() = default;
+ ReadEvents_Impl(ReadEvents_Impl&& other) = default;
+ ReadEvents_Impl& operator=(ReadEvents_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 SetWindowSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetWindowSize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::pty::WindowSize size);
+ ~SetWindowSize_Impl() = default;
+ SetWindowSize_Impl(SetWindowSize_Impl&& other) = default;
+ SetWindowSize_Impl& operator=(SetWindowSize_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using ReadAt = ReadAt_Impl<ReadAtResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using WriteAt = WriteAt_Impl<WriteAtResponse>;
+ using Seek = Seek_Impl<SeekResponse>;
+ using Truncate = Truncate_Impl<TruncateResponse>;
+ using GetFlags = GetFlags_Impl<GetFlagsResponse>;
+ using SetFlags = SetFlags_Impl<SetFlagsResponse>;
+ using GetBuffer = GetBuffer_Impl<GetBufferResponse>;
+ using OpenClient = OpenClient_Impl<OpenClientResponse>;
+ using ClrSetFeature = ClrSetFeature_Impl<ClrSetFeatureResponse>;
+ using GetWindowSize = GetWindowSize_Impl<GetWindowSizeResponse>;
+ using MakeActive = MakeActive_Impl<MakeActiveResponse>;
+ using ReadEvents = ReadEvents_Impl<ReadEventsResponse>;
+ using SetWindowSize = SetWindowSize_Impl<SetWindowSizeResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Read_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 ReadAt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+ ~ReadAt_Impl() = default;
+ ReadAt_Impl(ReadAt_Impl&& other) = default;
+ ReadAt_Impl& operator=(ReadAt_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 Write_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 WriteAt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+ ~WriteAt_Impl() = default;
+ WriteAt_Impl(WriteAt_Impl&& other) = default;
+ WriteAt_Impl& operator=(WriteAt_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 Seek_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Seek_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);
+ ~Seek_Impl() = default;
+ Seek_Impl(Seek_Impl&& other) = default;
+ Seek_Impl& operator=(Seek_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 Truncate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Truncate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+ ~Truncate_Impl() = default;
+ Truncate_Impl(Truncate_Impl&& other) = default;
+ Truncate_Impl& operator=(Truncate_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 GetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetFlags_Impl() = default;
+ GetFlags_Impl(GetFlags_Impl&& other) = default;
+ GetFlags_Impl& operator=(GetFlags_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 SetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~SetFlags_Impl() = default;
+ SetFlags_Impl(SetFlags_Impl&& other) = default;
+ SetFlags_Impl& operator=(SetFlags_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 GetBuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~GetBuffer_Impl() = default;
+ GetBuffer_Impl(GetBuffer_Impl&& other) = default;
+ GetBuffer_Impl& operator=(GetBuffer_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 OpenClient_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ OpenClient_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, ::zx::channel client, ::fidl::BytePart _response_buffer);
+ ~OpenClient_Impl() = default;
+ OpenClient_Impl(OpenClient_Impl&& other) = default;
+ OpenClient_Impl& operator=(OpenClient_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 ClrSetFeature_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ClrSetFeature_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer);
+ ~ClrSetFeature_Impl() = default;
+ ClrSetFeature_Impl(ClrSetFeature_Impl&& other) = default;
+ ClrSetFeature_Impl& operator=(ClrSetFeature_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 GetWindowSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetWindowSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetWindowSize_Impl() = default;
+ GetWindowSize_Impl(GetWindowSize_Impl&& other) = default;
+ GetWindowSize_Impl& operator=(GetWindowSize_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 MakeActive_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ MakeActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t client_pty_id, ::fidl::BytePart _response_buffer);
+ ~MakeActive_Impl() = default;
+ MakeActive_Impl(MakeActive_Impl&& other) = default;
+ MakeActive_Impl& operator=(MakeActive_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 ReadEvents_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadEvents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ReadEvents_Impl() = default;
+ ReadEvents_Impl(ReadEvents_Impl&& other) = default;
+ ReadEvents_Impl& operator=(ReadEvents_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 SetWindowSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetWindowSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer);
+ ~SetWindowSize_Impl() = default;
+ SetWindowSize_Impl(SetWindowSize_Impl&& other) = default;
+ SetWindowSize_Impl& operator=(SetWindowSize_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using ReadAt = ReadAt_Impl<ReadAtResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using WriteAt = WriteAt_Impl<WriteAtResponse>;
+ using Seek = Seek_Impl<SeekResponse>;
+ using Truncate = Truncate_Impl<TruncateResponse>;
+ using GetFlags = GetFlags_Impl<GetFlagsResponse>;
+ using SetFlags = SetFlags_Impl<SetFlagsResponse>;
+ using GetBuffer = GetBuffer_Impl<GetBufferResponse>;
+ using OpenClient = OpenClient_Impl<OpenClientResponse>;
+ using ClrSetFeature = ClrSetFeature_Impl<ClrSetFeatureResponse>;
+ using GetWindowSize = GetWindowSize_Impl<GetWindowSizeResponse>;
+ using MakeActive = MakeActive_Impl<MakeActiveResponse>;
+ using ReadEvents = ReadEvents_Impl<ReadEventsResponse>;
+ using SetWindowSize = SetWindowSize_Impl<SetWindowSizeResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Read Read(uint64_t count);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Read Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::ReadAt ReadAt(uint64_t count, uint64_t offset);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadAt ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Write Write(::fidl::VectorView<uint8_t> data);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Write Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::WriteAt WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteAt WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Seek Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Seek Seek(::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Truncate Truncate(uint64_t length);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Truncate Truncate(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetFlags GetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetFlags GetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetFlags SetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetFlags SetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetBuffer GetBuffer(uint32_t flags);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetBuffer GetBuffer(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Open a client PTY device with a unique `id`. `client` should be a handle
+ // to one endpoint of a channel that (on success) will become an open
+ // connection to the newly created device. On failure, the channel will be
+ // closed. Closing the channel will close the connection and release the
+ // device. If the provided `id` is 0, then the new client is a controlling
+ // client and has the capability to open additional clients. If the
+ // current device is not a controlling client, `ZX_ERR_ACCESS_DENIED` will be
+ // returned. If `id` is not unique, `ZX_ERR_INVALID_ARGS` will be returned.
+ // Otherwise the status code from `device_add` is passed on.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::OpenClient OpenClient(uint32_t id, ::zx::channel client);
+
+ // Open a client PTY device with a unique `id`. `client` should be a handle
+ // to one endpoint of a channel that (on success) will become an open
+ // connection to the newly created device. On failure, the channel will be
+ // closed. Closing the channel will close the connection and release the
+ // device. If the provided `id` is 0, then the new client is a controlling
+ // client and has the capability to open additional clients. If the
+ // current device is not a controlling client, `ZX_ERR_ACCESS_DENIED` will be
+ // returned. If `id` is not unique, `ZX_ERR_INVALID_ARGS` will be returned.
+ // Otherwise the status code from `device_add` is passed on.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OpenClient OpenClient(::fidl::BytePart _request_buffer, uint32_t id, ::zx::channel client, ::fidl::BytePart _response_buffer);
+
+ // allowed on Client PTYs
+ // -----------------------------
+ // Clear and/or Set PTY Features
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ClrSetFeature ClrSetFeature(uint32_t clr, uint32_t set);
+
+ // allowed on Client PTYs
+ // -----------------------------
+ // Clear and/or Set PTY Features
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ClrSetFeature ClrSetFeature(::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer);
+
+ // Obtain the window size (in character cells)
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetWindowSize GetWindowSize();
+
+ // Obtain the window size (in character cells)
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetWindowSize GetWindowSize(::fidl::BytePart _response_buffer);
+
+ // allowed on the Controlling PTY
+ // -------------------------------------
+ // Select which Client PTY receives input.
+ // Reads will simply block on non-active PTYs.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::MakeActive MakeActive(uint32_t client_pty_id);
+
+ // allowed on the Controlling PTY
+ // -------------------------------------
+ // Select which Client PTY receives input.
+ // Reads will simply block on non-active PTYs.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::MakeActive MakeActive(::fidl::BytePart _request_buffer, uint32_t client_pty_id, ::fidl::BytePart _response_buffer);
+
+ // Returns pending OOB events, simultaneously clearing them
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReadEvents ReadEvents();
+
+ // Returns pending OOB events, simultaneously clearing them
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadEvents ReadEvents(::fidl::BytePart _response_buffer);
+
+ // allowed on the Server PTY
+ // --------------------------------
+ // Sets the window size
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetWindowSize SetWindowSize(::llcpp::fuchsia::hardware::pty::WindowSize size);
+
+ // allowed on the Server PTY
+ // --------------------------------
+ // Sets the window size
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetWindowSize SetWindowSize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Read Read(::zx::unowned_channel _client_end, uint64_t count);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Read Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::ReadAt ReadAt(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadAt ReadAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::WriteAt WriteAt(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteAt WriteAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Seek Seek(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Seek Seek(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Truncate Truncate(::zx::unowned_channel _client_end, uint64_t length);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Truncate Truncate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetFlags GetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetFlags GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetFlags SetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetFlags SetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetBuffer GetBuffer(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetBuffer GetBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Open a client PTY device with a unique `id`. `client` should be a handle
+ // to one endpoint of a channel that (on success) will become an open
+ // connection to the newly created device. On failure, the channel will be
+ // closed. Closing the channel will close the connection and release the
+ // device. If the provided `id` is 0, then the new client is a controlling
+ // client and has the capability to open additional clients. If the
+ // current device is not a controlling client, `ZX_ERR_ACCESS_DENIED` will be
+ // returned. If `id` is not unique, `ZX_ERR_INVALID_ARGS` will be returned.
+ // Otherwise the status code from `device_add` is passed on.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::OpenClient OpenClient(::zx::unowned_channel _client_end, uint32_t id, ::zx::channel client);
+
+ // Open a client PTY device with a unique `id`. `client` should be a handle
+ // to one endpoint of a channel that (on success) will become an open
+ // connection to the newly created device. On failure, the channel will be
+ // closed. Closing the channel will close the connection and release the
+ // device. If the provided `id` is 0, then the new client is a controlling
+ // client and has the capability to open additional clients. If the
+ // current device is not a controlling client, `ZX_ERR_ACCESS_DENIED` will be
+ // returned. If `id` is not unique, `ZX_ERR_INVALID_ARGS` will be returned.
+ // Otherwise the status code from `device_add` is passed on.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OpenClient OpenClient(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, ::zx::channel client, ::fidl::BytePart _response_buffer);
+
+ // allowed on Client PTYs
+ // -----------------------------
+ // Clear and/or Set PTY Features
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ClrSetFeature ClrSetFeature(::zx::unowned_channel _client_end, uint32_t clr, uint32_t set);
+
+ // allowed on Client PTYs
+ // -----------------------------
+ // Clear and/or Set PTY Features
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ClrSetFeature ClrSetFeature(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t clr, uint32_t set, ::fidl::BytePart _response_buffer);
+
+ // Obtain the window size (in character cells)
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetWindowSize GetWindowSize(::zx::unowned_channel _client_end);
+
+ // Obtain the window size (in character cells)
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetWindowSize GetWindowSize(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // allowed on the Controlling PTY
+ // -------------------------------------
+ // Select which Client PTY receives input.
+ // Reads will simply block on non-active PTYs.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::MakeActive MakeActive(::zx::unowned_channel _client_end, uint32_t client_pty_id);
+
+ // allowed on the Controlling PTY
+ // -------------------------------------
+ // Select which Client PTY receives input.
+ // Reads will simply block on non-active PTYs.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::MakeActive MakeActive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t client_pty_id, ::fidl::BytePart _response_buffer);
+
+ // Returns pending OOB events, simultaneously clearing them
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReadEvents ReadEvents(::zx::unowned_channel _client_end);
+
+ // Returns pending OOB events, simultaneously clearing them
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadEvents ReadEvents(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // allowed on the Server PTY
+ // --------------------------------
+ // Sets the window size
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetWindowSize SetWindowSize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::pty::WindowSize size);
+
+ // allowed on the Server PTY
+ // --------------------------------
+ // Sets the window size
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetWindowSize SetWindowSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::pty::WindowSize size, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ static ::fidl::DecodeResult<ReadResponse> Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ static ::fidl::DecodeResult<ReadAtResponse> ReadAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<WriteResponse> Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<WriteAtResponse> WriteAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SeekResponse> Seek(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<TruncateResponse> Truncate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TruncateRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetFlagsResponse> GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SetFlagsResponse> SetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ static ::fidl::DecodeResult<GetBufferResponse> GetBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferRequest> params, ::fidl::BytePart response_buffer);
+
+ // Open a client PTY device with a unique `id`. `client` should be a handle
+ // to one endpoint of a channel that (on success) will become an open
+ // connection to the newly created device. On failure, the channel will be
+ // closed. Closing the channel will close the connection and release the
+ // device. If the provided `id` is 0, then the new client is a controlling
+ // client and has the capability to open additional clients. If the
+ // current device is not a controlling client, `ZX_ERR_ACCESS_DENIED` will be
+ // returned. If `id` is not unique, `ZX_ERR_INVALID_ARGS` will be returned.
+ // Otherwise the status code from `device_add` is passed on.
+ static ::fidl::DecodeResult<OpenClientResponse> OpenClient(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenClientRequest> params, ::fidl::BytePart response_buffer);
+
+ // allowed on Client PTYs
+ // -----------------------------
+ // Clear and/or Set PTY Features
+ static ::fidl::DecodeResult<ClrSetFeatureResponse> ClrSetFeature(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ClrSetFeatureRequest> params, ::fidl::BytePart response_buffer);
+
+ // Obtain the window size (in character cells)
+ static ::fidl::DecodeResult<GetWindowSizeResponse> GetWindowSize(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // allowed on the Controlling PTY
+ // -------------------------------------
+ // Select which Client PTY receives input.
+ // Reads will simply block on non-active PTYs.
+ static ::fidl::DecodeResult<MakeActiveResponse> MakeActive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MakeActiveRequest> params, ::fidl::BytePart response_buffer);
+
+ // Returns pending OOB events, simultaneously clearing them
+ static ::fidl::DecodeResult<ReadEventsResponse> ReadEvents(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // allowed on the Server PTY
+ // --------------------------------
+ // Sets the window size
+ static ::fidl::DecodeResult<SetWindowSizeResponse> SetWindowSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetWindowSizeRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class ReadCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<ReadResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadCompleter = ::fidl::Completer<ReadCompleterBase>;
+
+ virtual void Read(uint64_t count, ReadCompleter::Sync _completer) = 0;
+
+ class ReadAtCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<ReadAtResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadAtCompleter = ::fidl::Completer<ReadAtCompleterBase>;
+
+ virtual void ReadAt(uint64_t count, uint64_t offset, ReadAtCompleter::Sync _completer) = 0;
+
+ class WriteCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint64_t actual);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual);
+ void Reply(::fidl::DecodedMessage<WriteResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteCompleter = ::fidl::Completer<WriteCompleterBase>;
+
+ virtual void Write(::fidl::VectorView<uint8_t> data, WriteCompleter::Sync _completer) = 0;
+
+ class WriteAtCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint64_t actual);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual);
+ void Reply(::fidl::DecodedMessage<WriteAtResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteAtCompleter = ::fidl::Completer<WriteAtCompleterBase>;
+
+ virtual void WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset, WriteAtCompleter::Sync _completer) = 0;
+
+ class SeekCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint64_t offset);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t offset);
+ void Reply(::fidl::DecodedMessage<SeekResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SeekCompleter = ::fidl::Completer<SeekCompleterBase>;
+
+ virtual void Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, SeekCompleter::Sync _completer) = 0;
+
+ class TruncateCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<TruncateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using TruncateCompleter = ::fidl::Completer<TruncateCompleterBase>;
+
+ virtual void Truncate(uint64_t length, TruncateCompleter::Sync _completer) = 0;
+
+ class GetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<GetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetFlagsCompleter = ::fidl::Completer<GetFlagsCompleterBase>;
+
+ virtual void GetFlags(GetFlagsCompleter::Sync _completer) = 0;
+
+ class SetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetFlagsCompleter = ::fidl::Completer<SetFlagsCompleterBase>;
+
+ virtual void SetFlags(uint32_t flags, SetFlagsCompleter::Sync _completer) = 0;
+
+ class GetBufferCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer);
+ void Reply(::fidl::DecodedMessage<GetBufferResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetBufferCompleter = ::fidl::Completer<GetBufferCompleterBase>;
+
+ virtual void GetBuffer(uint32_t flags, GetBufferCompleter::Sync _completer) = 0;
+
+ class OpenClientCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<OpenClientResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using OpenClientCompleter = ::fidl::Completer<OpenClientCompleterBase>;
+
+ virtual void OpenClient(uint32_t id, ::zx::channel client, OpenClientCompleter::Sync _completer) = 0;
+
+ class ClrSetFeatureCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint32_t features);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint32_t features);
+ void Reply(::fidl::DecodedMessage<ClrSetFeatureResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ClrSetFeatureCompleter = ::fidl::Completer<ClrSetFeatureCompleterBase>;
+
+ virtual void ClrSetFeature(uint32_t clr, uint32_t set, ClrSetFeatureCompleter::Sync _completer) = 0;
+
+ class GetWindowSizeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::hardware::pty::WindowSize size);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::pty::WindowSize size);
+ void Reply(::fidl::DecodedMessage<GetWindowSizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetWindowSizeCompleter = ::fidl::Completer<GetWindowSizeCompleterBase>;
+
+ virtual void GetWindowSize(GetWindowSizeCompleter::Sync _completer) = 0;
+
+ class MakeActiveCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<MakeActiveResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using MakeActiveCompleter = ::fidl::Completer<MakeActiveCompleterBase>;
+
+ virtual void MakeActive(uint32_t client_pty_id, MakeActiveCompleter::Sync _completer) = 0;
+
+ class ReadEventsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint32_t events);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint32_t events);
+ void Reply(::fidl::DecodedMessage<ReadEventsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadEventsCompleter = ::fidl::Completer<ReadEventsCompleterBase>;
+
+ virtual void ReadEvents(ReadEventsCompleter::Sync _completer) = 0;
+
+ class SetWindowSizeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetWindowSizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetWindowSizeCompleter = ::fidl::Completer<SetWindowSizeCompleterBase>;
+
+ virtual void SetWindowSize(::llcpp::fuchsia::hardware::pty::WindowSize size, SetWindowSizeCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<Device::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Device::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<Device::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Device::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Device::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<Device::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Device::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Device::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<Device::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<Device::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<Device::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<Device::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<Device::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<Device::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<Device::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<Device::NodeSetFlagsResponse>& _msg);
+ static void ReadRequest(const ::fidl::DecodedMessage<Device::ReadRequest>& _msg);
+ static void ReadResponse(const ::fidl::DecodedMessage<Device::ReadResponse>& _msg);
+ static void ReadAtRequest(const ::fidl::DecodedMessage<Device::ReadAtRequest>& _msg);
+ static void ReadAtResponse(const ::fidl::DecodedMessage<Device::ReadAtResponse>& _msg);
+ static void WriteRequest(const ::fidl::DecodedMessage<Device::WriteRequest>& _msg);
+ static void WriteResponse(const ::fidl::DecodedMessage<Device::WriteResponse>& _msg);
+ static void WriteAtRequest(const ::fidl::DecodedMessage<Device::WriteAtRequest>& _msg);
+ static void WriteAtResponse(const ::fidl::DecodedMessage<Device::WriteAtResponse>& _msg);
+ static void SeekRequest(const ::fidl::DecodedMessage<Device::SeekRequest>& _msg);
+ static void SeekResponse(const ::fidl::DecodedMessage<Device::SeekResponse>& _msg);
+ static void TruncateRequest(const ::fidl::DecodedMessage<Device::TruncateRequest>& _msg);
+ static void TruncateResponse(const ::fidl::DecodedMessage<Device::TruncateResponse>& _msg);
+ static void GetFlagsRequest(const ::fidl::DecodedMessage<Device::GetFlagsRequest>& _msg);
+ static void GetFlagsResponse(const ::fidl::DecodedMessage<Device::GetFlagsResponse>& _msg);
+ static void SetFlagsRequest(const ::fidl::DecodedMessage<Device::SetFlagsRequest>& _msg);
+ static void SetFlagsResponse(const ::fidl::DecodedMessage<Device::SetFlagsResponse>& _msg);
+ static void GetBufferRequest(const ::fidl::DecodedMessage<Device::GetBufferRequest>& _msg);
+ static void GetBufferResponse(const ::fidl::DecodedMessage<Device::GetBufferResponse>& _msg);
+ static void OpenClientRequest(const ::fidl::DecodedMessage<Device::OpenClientRequest>& _msg);
+ static void OpenClientResponse(const ::fidl::DecodedMessage<Device::OpenClientResponse>& _msg);
+ static void ClrSetFeatureRequest(const ::fidl::DecodedMessage<Device::ClrSetFeatureRequest>& _msg);
+ static void ClrSetFeatureResponse(const ::fidl::DecodedMessage<Device::ClrSetFeatureResponse>& _msg);
+ static void GetWindowSizeRequest(const ::fidl::DecodedMessage<Device::GetWindowSizeRequest>& _msg);
+ static void GetWindowSizeResponse(const ::fidl::DecodedMessage<Device::GetWindowSizeResponse>& _msg);
+ static void MakeActiveRequest(const ::fidl::DecodedMessage<Device::MakeActiveRequest>& _msg);
+ static void MakeActiveResponse(const ::fidl::DecodedMessage<Device::MakeActiveResponse>& _msg);
+ static void ReadEventsRequest(const ::fidl::DecodedMessage<Device::ReadEventsRequest>& _msg);
+ static void ReadEventsResponse(const ::fidl::DecodedMessage<Device::ReadEventsResponse>& _msg);
+ static void SetWindowSizeRequest(const ::fidl::DecodedMessage<Device::SetWindowSizeRequest>& _msg);
+ static void SetWindowSizeResponse(const ::fidl::DecodedMessage<Device::SetWindowSizeResponse>& _msg);
+ };
+};
+
+// When an event is pending, this signal is asserted on the Controlling PTY.
+constexpr uint32_t SIGNAL_EVENT = 33554432u;
+
+// When Feature Raw is enabled, OOB Events like ^c, ^z, etc are not generated.
+// Instead the character is read from the read() input path.
+constexpr uint32_t FEATURE_RAW = 1u;
+
+// The terminal received a ^Z control character.
+constexpr uint32_t EVENT_SUSPEND = 4u;
+
+// All events
+constexpr uint32_t EVENT_MASK = 7u;
+
+// The terminal received a ^C control character.
+constexpr uint32_t EVENT_INTERRUPT = 2u;
+
+// The terminal has no active client.
+constexpr uint32_t EVENT_HANGUP = 1u;
+
+} // namespace pty
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::WindowSize> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::pty::WindowSize>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::WindowSize, width) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::WindowSize, height) == 4);
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::WindowSize) == ::llcpp::fuchsia::hardware::pty::WindowSize::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::CloneRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::CloseResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::DescribeResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::OnOpenResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SyncResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::GetAttrResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SetAttrRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SetAttrResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::ReadRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::ReadRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::ReadRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::ReadRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadRequest, count) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::ReadResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::ReadResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::ReadResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::ReadResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadResponse, data) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::ReadAtRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::ReadAtRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::ReadAtRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::ReadAtRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadAtRequest, count) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadAtRequest, offset) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::ReadAtResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::ReadAtResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::ReadAtResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::ReadAtResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadAtResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadAtResponse, data) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::WriteRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::WriteRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::WriteRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::WriteRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::WriteRequest, data) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::WriteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::WriteResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::WriteResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::WriteResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::WriteResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::WriteResponse, actual) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::WriteAtRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::WriteAtRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::WriteAtRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::WriteAtRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::WriteAtRequest, data) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::WriteAtRequest, offset) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::WriteAtResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::WriteAtResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::WriteAtResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::WriteAtResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::WriteAtResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::WriteAtResponse, actual) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SeekRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SeekRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SeekRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::SeekRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SeekRequest, offset) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SeekRequest, start) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SeekResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SeekResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SeekResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::SeekResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SeekResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SeekResponse, offset) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::TruncateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::TruncateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::TruncateRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::TruncateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::TruncateRequest, length) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::TruncateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::TruncateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::TruncateResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::TruncateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::TruncateResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::GetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::GetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::GetFlagsResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::GetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SetFlagsRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::SetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SetFlagsResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::SetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::GetBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::GetBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::GetBufferRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::GetBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetBufferRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::GetBufferResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::GetBufferResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::GetBufferResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::GetBufferResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetBufferResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetBufferResponse, buffer) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::OpenClientRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::OpenClientRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::OpenClientRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::OpenClientRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::OpenClientRequest, id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::OpenClientRequest, client) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::OpenClientResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::OpenClientResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::OpenClientResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::OpenClientResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::OpenClientResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureRequest, clr) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureRequest, set) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ClrSetFeatureResponse, features) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::GetWindowSizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::GetWindowSizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::GetWindowSizeResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::GetWindowSizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetWindowSizeResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::GetWindowSizeResponse, size) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::MakeActiveRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::MakeActiveRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::MakeActiveRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::MakeActiveRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::MakeActiveRequest, client_pty_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::MakeActiveResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::MakeActiveResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::MakeActiveResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::MakeActiveResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::MakeActiveResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::ReadEventsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::ReadEventsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::ReadEventsResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::ReadEventsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadEventsResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::ReadEventsResponse, events) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeRequest)
+ == ::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeRequest, size) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeResponse)
+ == ::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::pty::Device::SetWindowSizeResponse, status) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-securemem/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-securemem/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..3cc8436
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-securemem/gen/llcpp/fidl.cc
@@ -0,0 +1,178 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/securemem/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace securemem {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetSecureMemoryPhysicalAddress_Ordinal = 0x7f32703100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetSecureMemoryPhysicalAddress_GenOrdinal = 0x5f37764a495847f7lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_securemem_DeviceGetSecureMemoryPhysicalAddressRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_securemem_DeviceGetSecureMemoryPhysicalAddressResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetSecureMemoryPhysicalAddress_Impl<Device::GetSecureMemoryPhysicalAddressResponse>::GetSecureMemoryPhysicalAddress_Impl(::zx::unowned_channel _client_end, ::zx::vmo secure_mem) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSecureMemoryPhysicalAddressRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSecureMemoryPhysicalAddressRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSecureMemoryPhysicalAddressRequest*>(_write_bytes);
+ _request.secure_mem = std::move(secure_mem);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSecureMemoryPhysicalAddressRequest));
+ ::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetSecureMemoryPhysicalAddress(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetSecureMemoryPhysicalAddress Device::SyncClient::GetSecureMemoryPhysicalAddress(::zx::vmo secure_mem) {
+ return ResultOf::GetSecureMemoryPhysicalAddress(::zx::unowned_channel(this->channel_), std::move(secure_mem));
+}
+
+Device::ResultOf::GetSecureMemoryPhysicalAddress Device::Call::GetSecureMemoryPhysicalAddress(::zx::unowned_channel _client_end, ::zx::vmo secure_mem) {
+ return ResultOf::GetSecureMemoryPhysicalAddress(std::move(_client_end), std::move(secure_mem));
+}
+
+template <>
+Device::UnownedResultOf::GetSecureMemoryPhysicalAddress_Impl<Device::GetSecureMemoryPhysicalAddressResponse>::GetSecureMemoryPhysicalAddress_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo secure_mem, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetSecureMemoryPhysicalAddressRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetSecureMemoryPhysicalAddressResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetSecureMemoryPhysicalAddressRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSecureMemoryPhysicalAddressRequest*>(_request_buffer.data());
+ _request.secure_mem = std::move(secure_mem);
+ _request_buffer.set_actual(sizeof(GetSecureMemoryPhysicalAddressRequest));
+ ::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetSecureMemoryPhysicalAddress(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetSecureMemoryPhysicalAddress Device::SyncClient::GetSecureMemoryPhysicalAddress(::fidl::BytePart _request_buffer, ::zx::vmo secure_mem, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSecureMemoryPhysicalAddress(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(secure_mem), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetSecureMemoryPhysicalAddress Device::Call::GetSecureMemoryPhysicalAddress(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo secure_mem, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSecureMemoryPhysicalAddress(std::move(_client_end), std::move(_request_buffer), std::move(secure_mem), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetSecureMemoryPhysicalAddressResponse> Device::InPlace::GetSecureMemoryPhysicalAddress(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetSecureMemoryPhysicalAddressRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetSecureMemoryPhysicalAddressResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSecureMemoryPhysicalAddressRequest, GetSecureMemoryPhysicalAddressResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetSecureMemoryPhysicalAddressResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetSecureMemoryPhysicalAddress_Ordinal:
+ case kDevice_GetSecureMemoryPhysicalAddress_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSecureMemoryPhysicalAddressRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetSecureMemoryPhysicalAddress(std::move(message->secure_mem),
+ Interface::GetSecureMemoryPhysicalAddressCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetSecureMemoryPhysicalAddressCompleterBase::Reply(int32_t s, uint64_t paddr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSecureMemoryPhysicalAddressResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetSecureMemoryPhysicalAddressResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetSecureMemoryPhysicalAddressResponse(
+ ::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSecureMemoryPhysicalAddressResponse::PrimarySize,
+ GetSecureMemoryPhysicalAddressResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.paddr = std::move(paddr);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSecureMemoryPhysicalAddressResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetSecureMemoryPhysicalAddressCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t paddr) {
+ if (_buffer.capacity() < GetSecureMemoryPhysicalAddressResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetSecureMemoryPhysicalAddressResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetSecureMemoryPhysicalAddressResponse(
+ ::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSecureMemoryPhysicalAddressResponse::PrimarySize,
+ GetSecureMemoryPhysicalAddressResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.paddr = std::move(paddr);
+ _buffer.set_actual(sizeof(GetSecureMemoryPhysicalAddressResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetSecureMemoryPhysicalAddressCompleterBase::Reply(::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressResponse> params) {
+ Device::SetTransactionHeaderFor::GetSecureMemoryPhysicalAddressResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetSecureMemoryPhysicalAddressRequest(const ::fidl::DecodedMessage<Device::GetSecureMemoryPhysicalAddressRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetSecureMemoryPhysicalAddress_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetSecureMemoryPhysicalAddressResponse(const ::fidl::DecodedMessage<Device::GetSecureMemoryPhysicalAddressResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetSecureMemoryPhysicalAddress_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace securemem
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-securemem/gen/llcpp/include/fuchsia/hardware/securemem/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-securemem/gen/llcpp/include/fuchsia/hardware/securemem/llcpp/fidl.h
new file mode 100644
index 0000000..a1b4f67
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-securemem/gen/llcpp/include/fuchsia/hardware/securemem/llcpp/fidl.h
@@ -0,0 +1,285 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace securemem {
+
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_securemem_DeviceGetSecureMemoryPhysicalAddressRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_securemem_DeviceGetSecureMemoryPhysicalAddressResponseTable;
+
+// This protocol currently is a temporary measure to allow for services to get the physical address
+// of a previously pinned VMO until trusted services can be handed BTI handles.
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetSecureMemoryPhysicalAddressResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint64_t paddr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_securemem_DeviceGetSecureMemoryPhysicalAddressResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 GetSecureMemoryPhysicalAddressRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo secure_mem;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_securemem_DeviceGetSecureMemoryPhysicalAddressRequestTable;
+ 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 = GetSecureMemoryPhysicalAddressResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetSecureMemoryPhysicalAddress_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSecureMemoryPhysicalAddress_Impl(::zx::unowned_channel _client_end, ::zx::vmo secure_mem);
+ ~GetSecureMemoryPhysicalAddress_Impl() = default;
+ GetSecureMemoryPhysicalAddress_Impl(GetSecureMemoryPhysicalAddress_Impl&& other) = default;
+ GetSecureMemoryPhysicalAddress_Impl& operator=(GetSecureMemoryPhysicalAddress_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 GetSecureMemoryPhysicalAddress = GetSecureMemoryPhysicalAddress_Impl<GetSecureMemoryPhysicalAddressResponse>;
+ };
+
+ // 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 GetSecureMemoryPhysicalAddress_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSecureMemoryPhysicalAddress_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo secure_mem, ::fidl::BytePart _response_buffer);
+ ~GetSecureMemoryPhysicalAddress_Impl() = default;
+ GetSecureMemoryPhysicalAddress_Impl(GetSecureMemoryPhysicalAddress_Impl&& other) = default;
+ GetSecureMemoryPhysicalAddress_Impl& operator=(GetSecureMemoryPhysicalAddress_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 GetSecureMemoryPhysicalAddress = GetSecureMemoryPhysicalAddress_Impl<GetSecureMemoryPhysicalAddressResponse>;
+ };
+
+ 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_; }
+
+ // Gets the physical address of a previously pinned VMO.
+ //
+ // Note:
+ // * The VMO must be contiguous.
+ // * |secure_mem| is expected to have a stable physical address that is pinned by some other
+ // entity. The protocol implementation should not be expected to keep the VMO pinned.
+ // * The server implementation must not use an IOMMU-backed BTI handle, as the physical
+ // address of the VMO being pinned must be stable.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetSecureMemoryPhysicalAddress GetSecureMemoryPhysicalAddress(::zx::vmo secure_mem);
+
+ // Gets the physical address of a previously pinned VMO.
+ //
+ // Note:
+ // * The VMO must be contiguous.
+ // * |secure_mem| is expected to have a stable physical address that is pinned by some other
+ // entity. The protocol implementation should not be expected to keep the VMO pinned.
+ // * The server implementation must not use an IOMMU-backed BTI handle, as the physical
+ // address of the VMO being pinned must be stable.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSecureMemoryPhysicalAddress GetSecureMemoryPhysicalAddress(::fidl::BytePart _request_buffer, ::zx::vmo secure_mem, ::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:
+
+ // Gets the physical address of a previously pinned VMO.
+ //
+ // Note:
+ // * The VMO must be contiguous.
+ // * |secure_mem| is expected to have a stable physical address that is pinned by some other
+ // entity. The protocol implementation should not be expected to keep the VMO pinned.
+ // * The server implementation must not use an IOMMU-backed BTI handle, as the physical
+ // address of the VMO being pinned must be stable.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetSecureMemoryPhysicalAddress GetSecureMemoryPhysicalAddress(::zx::unowned_channel _client_end, ::zx::vmo secure_mem);
+
+ // Gets the physical address of a previously pinned VMO.
+ //
+ // Note:
+ // * The VMO must be contiguous.
+ // * |secure_mem| is expected to have a stable physical address that is pinned by some other
+ // entity. The protocol implementation should not be expected to keep the VMO pinned.
+ // * The server implementation must not use an IOMMU-backed BTI handle, as the physical
+ // address of the VMO being pinned must be stable.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSecureMemoryPhysicalAddress GetSecureMemoryPhysicalAddress(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo secure_mem, ::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:
+
+ // Gets the physical address of a previously pinned VMO.
+ //
+ // Note:
+ // * The VMO must be contiguous.
+ // * |secure_mem| is expected to have a stable physical address that is pinned by some other
+ // entity. The protocol implementation should not be expected to keep the VMO pinned.
+ // * The server implementation must not use an IOMMU-backed BTI handle, as the physical
+ // address of the VMO being pinned must be stable.
+ static ::fidl::DecodeResult<GetSecureMemoryPhysicalAddressResponse> GetSecureMemoryPhysicalAddress(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetSecureMemoryPhysicalAddressCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint64_t paddr);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t paddr);
+ void Reply(::fidl::DecodedMessage<GetSecureMemoryPhysicalAddressResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSecureMemoryPhysicalAddressCompleter = ::fidl::Completer<GetSecureMemoryPhysicalAddressCompleterBase>;
+
+ virtual void GetSecureMemoryPhysicalAddress(::zx::vmo secure_mem, GetSecureMemoryPhysicalAddressCompleter::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 GetSecureMemoryPhysicalAddressRequest(const ::fidl::DecodedMessage<Device::GetSecureMemoryPhysicalAddressRequest>& _msg);
+ static void GetSecureMemoryPhysicalAddressResponse(const ::fidl::DecodedMessage<Device::GetSecureMemoryPhysicalAddressResponse>& _msg);
+ };
+};
+
+} // namespace securemem
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressRequest)
+ == ::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressRequest, secure_mem) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressResponse)
+ == ::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::securemem::Device::GetSecureMemoryPhysicalAddressResponse, paddr) == 24);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-serial/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-serial/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..d33e449
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-serial/gen/llcpp/fidl.cc
@@ -0,0 +1,1021 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/serial/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace serial {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kNewDeviceProxy_GetChannel_Ordinal = 0x2a01059e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNewDeviceProxy_GetChannel_GenOrdinal = 0x612d461fef5c62e5lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceProxyGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceProxyGetChannelResponseTable;
+
+} // namespace
+
+NewDeviceProxy::ResultOf::GetChannel_Impl::GetChannel_Impl(::zx::unowned_channel _client_end, ::zx::channel req) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChannelRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetChannelRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetChannelRequest*>(_write_bytes);
+ _request.req = std::move(req);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ NewDeviceProxy::InPlace::GetChannel(std::move(_client_end), std::move(_decoded_request)));
+}
+
+NewDeviceProxy::ResultOf::GetChannel NewDeviceProxy::SyncClient::GetChannel(::zx::channel req) {
+ return ResultOf::GetChannel(::zx::unowned_channel(this->channel_), std::move(req));
+}
+
+NewDeviceProxy::ResultOf::GetChannel NewDeviceProxy::Call::GetChannel(::zx::unowned_channel _client_end, ::zx::channel req) {
+ return ResultOf::GetChannel(std::move(_client_end), std::move(req));
+}
+
+
+NewDeviceProxy::UnownedResultOf::GetChannel_Impl::GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel req) {
+ if (_request_buffer.capacity() < GetChannelRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetChannelRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetChannelRequest*>(_request_buffer.data());
+ _request.req = std::move(req);
+ _request_buffer.set_actual(sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ NewDeviceProxy::InPlace::GetChannel(std::move(_client_end), std::move(_decoded_request)));
+}
+
+NewDeviceProxy::UnownedResultOf::GetChannel NewDeviceProxy::SyncClient::GetChannel(::fidl::BytePart _request_buffer, ::zx::channel req) {
+ return UnownedResultOf::GetChannel(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(req));
+}
+
+NewDeviceProxy::UnownedResultOf::GetChannel NewDeviceProxy::Call::GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel req) {
+ return UnownedResultOf::GetChannel(std::move(_client_end), std::move(_request_buffer), std::move(req));
+}
+
+::fidl::internal::StatusAndError NewDeviceProxy::InPlace::GetChannel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetChannelRequest> params) {
+ NewDeviceProxy::SetTransactionHeaderFor::GetChannelRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool NewDeviceProxy::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kNewDeviceProxy_GetChannel_Ordinal:
+ case kNewDeviceProxy_GetChannel_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetChannelRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetChannel(std::move(message->req),
+ Interface::GetChannelCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool NewDeviceProxy::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void NewDeviceProxy::SetTransactionHeaderFor::GetChannelRequest(const ::fidl::DecodedMessage<NewDeviceProxy::GetChannelRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDeviceProxy_GetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::hardware::serial::NewDevice_Write_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(NewDevice_Write_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(NewDevice_Write_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(NewDevice_Write_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::hardware::serial::NewDevice_Read_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(NewDevice_Read_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(NewDevice_Read_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(NewDevice_Read_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetClass_Ordinal = 0x6549990f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetClass_GenOrdinal = 0x3d48bbcee248ab8blu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_DeviceGetClassRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_DeviceGetClassResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetConfig_Ordinal = 0x10bcc68c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetConfig_GenOrdinal = 0x771a0946f6f87173lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_DeviceSetConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_DeviceSetConfigResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetClass_Impl<Device::GetClassResponse>::GetClass_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetClassRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetClassRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetClassRequest));
+ ::fidl::DecodedMessage<GetClassRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetClass(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetClass Device::SyncClient::GetClass() {
+ return ResultOf::GetClass(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetClass Device::Call::GetClass(::zx::unowned_channel _client_end) {
+ return ResultOf::GetClass(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetClass_Impl<Device::GetClassResponse>::GetClass_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetClassRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetClassRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetClassRequest));
+ ::fidl::DecodedMessage<GetClassRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetClass(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetClass Device::SyncClient::GetClass(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetClass(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetClass Device::Call::GetClass(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetClass(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetClassResponse> Device::InPlace::GetClass(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetClassRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetClassRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetClassRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetClassResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetClassRequest, GetClassResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetClassResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetConfig_Impl<Device::SetConfigResponse>::SetConfig_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::serial::Config config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigRequest*>(_write_bytes);
+ _request.config = std::move(config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigRequest));
+ ::fidl::DecodedMessage<SetConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetConfig(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetConfig Device::SyncClient::SetConfig(::llcpp::fuchsia::hardware::serial::Config config) {
+ return ResultOf::SetConfig(::zx::unowned_channel(this->channel_), std::move(config));
+}
+
+Device::ResultOf::SetConfig Device::Call::SetConfig(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::serial::Config config) {
+ return ResultOf::SetConfig(std::move(_client_end), std::move(config));
+}
+
+template <>
+Device::UnownedResultOf::SetConfig_Impl<Device::SetConfigResponse>::SetConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetConfigRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetConfigResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigRequest*>(_request_buffer.data());
+ _request.config = std::move(config);
+ _request_buffer.set_actual(sizeof(SetConfigRequest));
+ ::fidl::DecodedMessage<SetConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetConfig(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetConfig Device::SyncClient::SetConfig(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetConfig Device::Call::SetConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfig(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetConfigResponse> Device::InPlace::SetConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetConfigRequest, SetConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetClass_Ordinal:
+ case kDevice_GetClass_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetClassRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetClass(
+ Interface::GetClassCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetConfig_Ordinal:
+ case kDevice_SetConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetConfig(std::move(message->config),
+ Interface::SetConfigCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetClassCompleterBase::Reply(::llcpp::fuchsia::hardware::serial::Class device_class) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetClassResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetClassResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetClassResponse(
+ ::fidl::DecodedMessage<GetClassResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetClassResponse::PrimarySize,
+ GetClassResponse::PrimarySize)));
+ _response.device_class = std::move(device_class);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetClassResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetClassResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetClassCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::serial::Class device_class) {
+ if (_buffer.capacity() < GetClassResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetClassResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetClassResponse(
+ ::fidl::DecodedMessage<GetClassResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetClassResponse::PrimarySize,
+ GetClassResponse::PrimarySize)));
+ _response.device_class = std::move(device_class);
+ _buffer.set_actual(sizeof(GetClassResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetClassResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetClassCompleterBase::Reply(::fidl::DecodedMessage<GetClassResponse> params) {
+ Device::SetTransactionHeaderFor::GetClassResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetConfigCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetConfigResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetConfigResponse(
+ ::fidl::DecodedMessage<SetConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigResponse::PrimarySize,
+ SetConfigResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetConfigCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetConfigResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetConfigResponse(
+ ::fidl::DecodedMessage<SetConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigResponse::PrimarySize,
+ SetConfigResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetConfigResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetConfigCompleterBase::Reply(::fidl::DecodedMessage<SetConfigResponse> params) {
+ Device::SetTransactionHeaderFor::SetConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetClassRequest(const ::fidl::DecodedMessage<Device::GetClassRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetClass_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetClassResponse(const ::fidl::DecodedMessage<Device::GetClassResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetClass_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetConfigRequest(const ::fidl::DecodedMessage<Device::SetConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetConfigResponse(const ::fidl::DecodedMessage<Device::SetConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kNewDevice_GetClass_Ordinal = 0x6549990f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNewDevice_GetClass_GenOrdinal = 0x3d48bbcee248ab8blu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceGetClassRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceGetClassResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNewDevice_SetConfig_Ordinal = 0x10bcc68c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNewDevice_SetConfig_GenOrdinal = 0x771a0946f6f87173lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceSetConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceSetConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNewDevice_Read_Ordinal = 0x1a6f49f800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNewDevice_Read_GenOrdinal = 0xc2570dbef247548lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceReadResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNewDevice_Write_Ordinal = 0x4a3e8e3f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNewDevice_Write_GenOrdinal = 0x4238cc1d50b60487lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceWriteResponseTable;
+
+} // namespace
+template <>
+NewDevice::ResultOf::GetClass_Impl<NewDevice::GetClassResponse>::GetClass_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetClassRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetClassRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetClassRequest));
+ ::fidl::DecodedMessage<GetClassRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ NewDevice::InPlace::GetClass(std::move(_client_end), Super::response_buffer()));
+}
+
+NewDevice::ResultOf::GetClass NewDevice::SyncClient::GetClass() {
+ return ResultOf::GetClass(::zx::unowned_channel(this->channel_));
+}
+
+NewDevice::ResultOf::GetClass NewDevice::Call::GetClass(::zx::unowned_channel _client_end) {
+ return ResultOf::GetClass(std::move(_client_end));
+}
+
+template <>
+NewDevice::UnownedResultOf::GetClass_Impl<NewDevice::GetClassResponse>::GetClass_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetClassRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetClassRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetClassRequest));
+ ::fidl::DecodedMessage<GetClassRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ NewDevice::InPlace::GetClass(std::move(_client_end), std::move(_response_buffer)));
+}
+
+NewDevice::UnownedResultOf::GetClass NewDevice::SyncClient::GetClass(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetClass(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+NewDevice::UnownedResultOf::GetClass NewDevice::Call::GetClass(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetClass(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<NewDevice::GetClassResponse> NewDevice::InPlace::GetClass(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetClassRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetClassRequest> params(std::move(_request_buffer));
+ NewDevice::SetTransactionHeaderFor::GetClassRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NewDevice::GetClassResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetClassRequest, GetClassResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NewDevice::GetClassResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+NewDevice::ResultOf::SetConfig_Impl<NewDevice::SetConfigResponse>::SetConfig_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::serial::Config config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigRequest*>(_write_bytes);
+ _request.config = std::move(config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigRequest));
+ ::fidl::DecodedMessage<SetConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ NewDevice::InPlace::SetConfig(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+NewDevice::ResultOf::SetConfig NewDevice::SyncClient::SetConfig(::llcpp::fuchsia::hardware::serial::Config config) {
+ return ResultOf::SetConfig(::zx::unowned_channel(this->channel_), std::move(config));
+}
+
+NewDevice::ResultOf::SetConfig NewDevice::Call::SetConfig(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::serial::Config config) {
+ return ResultOf::SetConfig(std::move(_client_end), std::move(config));
+}
+
+template <>
+NewDevice::UnownedResultOf::SetConfig_Impl<NewDevice::SetConfigResponse>::SetConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetConfigRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetConfigResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigRequest*>(_request_buffer.data());
+ _request.config = std::move(config);
+ _request_buffer.set_actual(sizeof(SetConfigRequest));
+ ::fidl::DecodedMessage<SetConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ NewDevice::InPlace::SetConfig(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+NewDevice::UnownedResultOf::SetConfig NewDevice::SyncClient::SetConfig(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+NewDevice::UnownedResultOf::SetConfig NewDevice::Call::SetConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfig(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<NewDevice::SetConfigResponse> NewDevice::InPlace::SetConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigRequest> params, ::fidl::BytePart response_buffer) {
+ NewDevice::SetTransactionHeaderFor::SetConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NewDevice::SetConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetConfigRequest, SetConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NewDevice::SetConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+NewDevice::ResultOf::Read_Impl<NewDevice::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ NewDevice::InPlace::Read(std::move(_client_end), Super::response_buffer()));
+}
+
+NewDevice::ResultOf::Read NewDevice::SyncClient::Read() {
+ return ResultOf::Read(::zx::unowned_channel(this->channel_));
+}
+
+NewDevice::ResultOf::Read NewDevice::Call::Read(::zx::unowned_channel _client_end) {
+ return ResultOf::Read(std::move(_client_end));
+}
+
+template <>
+NewDevice::UnownedResultOf::Read_Impl<NewDevice::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ReadRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ReadRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ NewDevice::InPlace::Read(std::move(_client_end), std::move(_response_buffer)));
+}
+
+NewDevice::UnownedResultOf::Read NewDevice::SyncClient::Read(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+NewDevice::UnownedResultOf::Read NewDevice::Call::Read(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<NewDevice::ReadResponse> NewDevice::InPlace::Read(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ReadRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ReadRequest> params(std::move(_request_buffer));
+ NewDevice::SetTransactionHeaderFor::ReadRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NewDevice::ReadResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadRequest, ReadResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NewDevice::ReadResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+NewDevice::ResultOf::Write_Impl<NewDevice::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ NewDevice::InPlace::Write(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+NewDevice::ResultOf::Write NewDevice::SyncClient::Write(::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Write(::zx::unowned_channel(this->channel_), std::move(data));
+}
+
+NewDevice::ResultOf::Write NewDevice::Call::Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Write(std::move(_client_end), std::move(data));
+}
+
+template <>
+NewDevice::UnownedResultOf::Write_Impl<NewDevice::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ NewDevice::InPlace::Write(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+NewDevice::UnownedResultOf::Write NewDevice::SyncClient::Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+NewDevice::UnownedResultOf::Write NewDevice::Call::Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<NewDevice::WriteResponse> NewDevice::InPlace::Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer) {
+ NewDevice::SetTransactionHeaderFor::WriteRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NewDevice::WriteResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NewDevice::WriteResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool NewDevice::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kNewDevice_GetClass_Ordinal:
+ case kNewDevice_GetClass_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetClassRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetClass(
+ Interface::GetClassCompleter::Sync(txn));
+ return true;
+ }
+ case kNewDevice_SetConfig_Ordinal:
+ case kNewDevice_SetConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetConfig(std::move(message->config),
+ Interface::SetConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kNewDevice_Read_Ordinal:
+ case kNewDevice_Read_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Read(
+ Interface::ReadCompleter::Sync(txn));
+ return true;
+ }
+ case kNewDevice_Write_Ordinal:
+ case kNewDevice_Write_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Write(std::move(message->data),
+ Interface::WriteCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool NewDevice::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void NewDevice::Interface::GetClassCompleterBase::Reply(::llcpp::fuchsia::hardware::serial::Class device_class) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetClassResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetClassResponse*>(_write_bytes);
+ NewDevice::SetTransactionHeaderFor::GetClassResponse(
+ ::fidl::DecodedMessage<GetClassResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetClassResponse::PrimarySize,
+ GetClassResponse::PrimarySize)));
+ _response.device_class = std::move(device_class);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetClassResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetClassResponse>(std::move(_response_bytes)));
+}
+
+void NewDevice::Interface::GetClassCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::serial::Class device_class) {
+ if (_buffer.capacity() < GetClassResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetClassResponse*>(_buffer.data());
+ NewDevice::SetTransactionHeaderFor::GetClassResponse(
+ ::fidl::DecodedMessage<GetClassResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetClassResponse::PrimarySize,
+ GetClassResponse::PrimarySize)));
+ _response.device_class = std::move(device_class);
+ _buffer.set_actual(sizeof(GetClassResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetClassResponse>(std::move(_buffer)));
+}
+
+void NewDevice::Interface::GetClassCompleterBase::Reply(::fidl::DecodedMessage<GetClassResponse> params) {
+ NewDevice::SetTransactionHeaderFor::GetClassResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void NewDevice::Interface::SetConfigCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetConfigResponse*>(_write_bytes);
+ NewDevice::SetTransactionHeaderFor::SetConfigResponse(
+ ::fidl::DecodedMessage<SetConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigResponse::PrimarySize,
+ SetConfigResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigResponse>(std::move(_response_bytes)));
+}
+
+void NewDevice::Interface::SetConfigCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetConfigResponse*>(_buffer.data());
+ NewDevice::SetTransactionHeaderFor::SetConfigResponse(
+ ::fidl::DecodedMessage<SetConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigResponse::PrimarySize,
+ SetConfigResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetConfigResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigResponse>(std::move(_buffer)));
+}
+
+void NewDevice::Interface::SetConfigCompleterBase::Reply(::fidl::DecodedMessage<SetConfigResponse> params) {
+ NewDevice::SetTransactionHeaderFor::SetConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void NewDevice::Interface::ReadCompleterBase::Reply(::llcpp::fuchsia::hardware::serial::NewDevice_Read_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadResponse _response = {};
+ NewDevice::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NewDevice::Interface::ReadCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> data) {
+ NewDevice_Read_Response response;
+ response.data = std::move(data);
+
+ Reply(NewDevice_Read_Result::WithResponse(&response));
+}
+void NewDevice::Interface::ReadCompleterBase::ReplyError(int32_t error) {
+ Reply(NewDevice_Read_Result::WithErr(&error));
+}
+
+void NewDevice::Interface::ReadCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::serial::NewDevice_Read_Result result) {
+ if (_buffer.capacity() < ReadResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadResponse _response = {};
+ NewDevice::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NewDevice::Interface::ReadCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data) {
+ NewDevice_Read_Response response;
+ response.data = std::move(data);
+
+ Reply(std::move(_buffer), NewDevice_Read_Result::WithResponse(&response));
+}
+
+void NewDevice::Interface::ReadCompleterBase::Reply(::fidl::DecodedMessage<ReadResponse> params) {
+ NewDevice::SetTransactionHeaderFor::ReadResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void NewDevice::Interface::WriteCompleterBase::Reply(::llcpp::fuchsia::hardware::serial::NewDevice_Write_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ WriteResponse _response = {};
+ NewDevice::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NewDevice::Interface::WriteCompleterBase::ReplySuccess() {
+ NewDevice_Write_Response response;
+
+ Reply(NewDevice_Write_Result::WithResponse(&response));
+}
+void NewDevice::Interface::WriteCompleterBase::ReplyError(int32_t error) {
+ Reply(NewDevice_Write_Result::WithErr(&error));
+}
+
+void NewDevice::Interface::WriteCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::serial::NewDevice_Write_Result result) {
+ if (_buffer.capacity() < WriteResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WriteResponse _response = {};
+ NewDevice::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NewDevice::Interface::WriteCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ NewDevice_Write_Response response;
+
+ Reply(std::move(_buffer), NewDevice_Write_Result::WithResponse(&response));
+}
+
+void NewDevice::Interface::WriteCompleterBase::Reply(::fidl::DecodedMessage<WriteResponse> params) {
+ NewDevice::SetTransactionHeaderFor::WriteResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void NewDevice::SetTransactionHeaderFor::GetClassRequest(const ::fidl::DecodedMessage<NewDevice::GetClassRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDevice_GetClass_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void NewDevice::SetTransactionHeaderFor::GetClassResponse(const ::fidl::DecodedMessage<NewDevice::GetClassResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDevice_GetClass_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void NewDevice::SetTransactionHeaderFor::SetConfigRequest(const ::fidl::DecodedMessage<NewDevice::SetConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDevice_SetConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void NewDevice::SetTransactionHeaderFor::SetConfigResponse(const ::fidl::DecodedMessage<NewDevice::SetConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDevice_SetConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void NewDevice::SetTransactionHeaderFor::ReadRequest(const ::fidl::DecodedMessage<NewDevice::ReadRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDevice_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void NewDevice::SetTransactionHeaderFor::ReadResponse(const ::fidl::DecodedMessage<NewDevice::ReadResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDevice_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void NewDevice::SetTransactionHeaderFor::WriteRequest(const ::fidl::DecodedMessage<NewDevice::WriteRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDevice_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void NewDevice::SetTransactionHeaderFor::WriteResponse(const ::fidl::DecodedMessage<NewDevice::WriteResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNewDevice_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace serial
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-serial/gen/llcpp/include/fuchsia/hardware/serial/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-serial/gen/llcpp/include/fuchsia/hardware/serial/llcpp/fidl.h
new file mode 100644
index 0000000..4b350ea
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-serial/gen/llcpp/include/fuchsia/hardware/serial/llcpp/fidl.h
@@ -0,0 +1,1321 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace serial {
+
+enum class StopWidth : uint8_t {
+ BITS_1 = 1u,
+ BITS_2 = 2u,
+};
+
+
+class NewDeviceProxy;
+enum class Parity : uint8_t {
+ NONE = 1u,
+ EVEN = 2u,
+ ODD = 3u,
+};
+
+
+struct NewDevice_Write_Response;
+struct NewDevice_Write_Result;
+struct NewDevice_Read_Response;
+struct NewDevice_Read_Result;
+enum class FlowControl : uint8_t {
+ NONE = 1u,
+ CTS_RTS = 2u,
+};
+
+
+enum class Class : uint8_t {
+ GENERIC = 1u,
+ BLUETOOTH_HCI = 2u,
+ CONSOLE = 3u,
+};
+
+
+enum class CharacterWidth : uint8_t {
+ BITS_5 = 1u,
+ BITS_6 = 2u,
+ BITS_7 = 3u,
+ BITS_8 = 4u,
+};
+
+
+struct Config;
+class Device;
+class NewDevice;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDevice_Write_ResultTable;
+
+struct NewDevice_Write_Result {
+ NewDevice_Write_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static NewDevice_Write_Result WithResponse(::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response* val) {
+ NewDevice_Write_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static NewDevice_Write_Result WithErr(int32_t* val) {
+ NewDevice_Write_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDevice_Write_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDevice_Read_ResultTable;
+
+struct NewDevice_Read_Result {
+ NewDevice_Read_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static NewDevice_Read_Result WithResponse(::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response* val) {
+ NewDevice_Read_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static NewDevice_Read_Result WithErr(int32_t* val) {
+ NewDevice_Read_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDevice_Read_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceProxyGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceProxyGetChannelResponseTable;
+
+class NewDeviceProxy final {
+ NewDeviceProxy() = delete;
+ public:
+
+ struct GetChannelRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel req;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDeviceProxyGetChannelRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class GetChannel_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end, ::zx::channel req);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using GetChannel = GetChannel_Impl;
+ };
+
+ // 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:
+ class GetChannel_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel req);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using GetChannel = GetChannel_Impl;
+ };
+
+ 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 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetChannel GetChannel(::zx::channel req);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetChannel GetChannel(::fidl::BytePart _request_buffer, ::zx::channel req);
+
+ 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 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetChannel GetChannel(::zx::unowned_channel _client_end, ::zx::channel req);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetChannel GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel req);
+
+ };
+
+ // 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::internal::StatusAndError GetChannel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetChannelRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = NewDeviceProxy;
+ using _Base = ::fidl::CompleterBase;
+
+ using GetChannelCompleter = ::fidl::Completer<>;
+
+ virtual void GetChannel(::zx::channel req, GetChannelCompleter::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 GetChannelRequest(const ::fidl::DecodedMessage<NewDeviceProxy::GetChannelRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDevice_Write_ResponseTable;
+
+struct NewDevice_Write_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDevice_Write_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDevice_Read_ResponseTable;
+
+struct NewDevice_Read_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDevice_Read_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint8_t> data = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_ConfigTable;
+
+struct Config {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_ConfigTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::hardware::serial::CharacterWidth character_width = {};
+
+ ::llcpp::fuchsia::hardware::serial::StopWidth stop_width = {};
+
+ ::llcpp::fuchsia::hardware::serial::Parity parity = {};
+
+ ::llcpp::fuchsia::hardware::serial::FlowControl control_flow = {};
+
+ uint32_t baud_rate = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_DeviceGetClassRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_DeviceGetClassResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_DeviceSetConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_DeviceSetConfigResponseTable;
+
+// Legacy synchronous device interface.
+// New drivers should implement NewDevice instead.
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetClassResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::serial::Class device_class;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_DeviceGetClassResponseTable;
+ 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 GetClassRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_DeviceSetConfigResponseTable;
+ 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 SetConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::serial::Config config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_DeviceSetConfigRequestTable;
+ 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 = SetConfigResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetClass_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetClass_Impl(::zx::unowned_channel _client_end);
+ ~GetClass_Impl() = default;
+ GetClass_Impl(GetClass_Impl&& other) = default;
+ GetClass_Impl& operator=(GetClass_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 SetConfig_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetConfig_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::serial::Config config);
+ ~SetConfig_Impl() = default;
+ SetConfig_Impl(SetConfig_Impl&& other) = default;
+ SetConfig_Impl& operator=(SetConfig_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 GetClass = GetClass_Impl<GetClassResponse>;
+ using SetConfig = SetConfig_Impl<SetConfigResponse>;
+ };
+
+ // 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 GetClass_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetClass_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetClass_Impl() = default;
+ GetClass_Impl(GetClass_Impl&& other) = default;
+ GetClass_Impl& operator=(GetClass_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 SetConfig_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer);
+ ~SetConfig_Impl() = default;
+ SetConfig_Impl(SetConfig_Impl&& other) = default;
+ SetConfig_Impl& operator=(SetConfig_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 GetClass = GetClass_Impl<GetClassResponse>;
+ using SetConfig = SetConfig_Impl<SetConfigResponse>;
+ };
+
+ 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_; }
+
+ // Lookup what type of serial device this is.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetClass GetClass();
+
+ // Lookup what type of serial device this is.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetClass GetClass(::fidl::BytePart _response_buffer);
+
+ // Set the configuration of this serial device.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetConfig SetConfig(::llcpp::fuchsia::hardware::serial::Config config);
+
+ // Set the configuration of this serial device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetConfig SetConfig(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::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:
+
+ // Lookup what type of serial device this is.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetClass GetClass(::zx::unowned_channel _client_end);
+
+ // Lookup what type of serial device this is.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetClass GetClass(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Set the configuration of this serial device.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetConfig SetConfig(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::serial::Config config);
+
+ // Set the configuration of this serial device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetConfig SetConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::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:
+
+ // Lookup what type of serial device this is.
+ static ::fidl::DecodeResult<GetClassResponse> GetClass(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Set the configuration of this serial device.
+ static ::fidl::DecodeResult<SetConfigResponse> SetConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetClassCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::serial::Class device_class);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::serial::Class device_class);
+ void Reply(::fidl::DecodedMessage<GetClassResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetClassCompleter = ::fidl::Completer<GetClassCompleterBase>;
+
+ virtual void GetClass(GetClassCompleter::Sync _completer) = 0;
+
+ class SetConfigCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetConfigCompleter = ::fidl::Completer<SetConfigCompleterBase>;
+
+ virtual void SetConfig(::llcpp::fuchsia::hardware::serial::Config config, SetConfigCompleter::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 GetClassRequest(const ::fidl::DecodedMessage<Device::GetClassRequest>& _msg);
+ static void GetClassResponse(const ::fidl::DecodedMessage<Device::GetClassResponse>& _msg);
+ static void SetConfigRequest(const ::fidl::DecodedMessage<Device::SetConfigRequest>& _msg);
+ static void SetConfigResponse(const ::fidl::DecodedMessage<Device::SetConfigResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceGetClassRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceGetClassResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceSetConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceSetConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceReadResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_serial_NewDeviceWriteResponseTable;
+
+// FIDL device utilizing the new asynchronous serial driver
+// instead of the synchronous FDIO-backed read/write interface.
+// New drivers should implement this instead of the Device interface above.
+class NewDevice final {
+ NewDevice() = delete;
+ public:
+
+ struct GetClassResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::serial::Class device_class;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDeviceGetClassResponseTable;
+ 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 GetClassRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDeviceSetConfigResponseTable;
+ 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 SetConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::serial::Config config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDeviceSetConfigRequestTable;
+ 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 = SetConfigResponse;
+ };
+
+ struct ReadResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::serial::NewDevice_Read_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDeviceReadResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using ReadRequest = ::fidl::AnyZeroArgMessage;
+
+ struct WriteResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::serial::NewDevice_Write_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDeviceWriteResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct WriteRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_serial_NewDeviceWriteRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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 = WriteResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetClass_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetClass_Impl(::zx::unowned_channel _client_end);
+ ~GetClass_Impl() = default;
+ GetClass_Impl(GetClass_Impl&& other) = default;
+ GetClass_Impl& operator=(GetClass_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 SetConfig_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetConfig_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::serial::Config config);
+ ~SetConfig_Impl() = default;
+ SetConfig_Impl(SetConfig_Impl&& other) = default;
+ SetConfig_Impl& operator=(SetConfig_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 Read_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 Write_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 GetClass = GetClass_Impl<GetClassResponse>;
+ using SetConfig = SetConfig_Impl<SetConfigResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ };
+
+ // 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 GetClass_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetClass_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetClass_Impl() = default;
+ GetClass_Impl(GetClass_Impl&& other) = default;
+ GetClass_Impl& operator=(GetClass_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 SetConfig_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer);
+ ~SetConfig_Impl() = default;
+ SetConfig_Impl(SetConfig_Impl&& other) = default;
+ SetConfig_Impl& operator=(SetConfig_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 Read_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 Write_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 GetClass = GetClass_Impl<GetClassResponse>;
+ using SetConfig = SetConfig_Impl<SetConfigResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ };
+
+ 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_; }
+
+ // Lookup what type of serial device this is.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetClass GetClass();
+
+ // Lookup what type of serial device this is.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetClass GetClass(::fidl::BytePart _response_buffer);
+
+ // Set the configuration of this serial device.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetConfig SetConfig(::llcpp::fuchsia::hardware::serial::Config config);
+
+ // Set the configuration of this serial device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetConfig SetConfig(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer);
+
+ // Reads data from the serial port
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Read Read();
+
+ // Reads data from the serial port
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Read Read(::fidl::BytePart _response_buffer);
+
+ // Writes data to the serial port
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Write Write(::fidl::VectorView<uint8_t> data);
+
+ // Writes data to the serial port
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Write Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::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:
+
+ // Lookup what type of serial device this is.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetClass GetClass(::zx::unowned_channel _client_end);
+
+ // Lookup what type of serial device this is.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetClass GetClass(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Set the configuration of this serial device.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetConfig SetConfig(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::serial::Config config);
+
+ // Set the configuration of this serial device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetConfig SetConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::serial::Config config, ::fidl::BytePart _response_buffer);
+
+ // Reads data from the serial port
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Read Read(::zx::unowned_channel _client_end);
+
+ // Reads data from the serial port
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Read Read(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Writes data to the serial port
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+
+ // Writes data to the serial port
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::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:
+
+ // Lookup what type of serial device this is.
+ static ::fidl::DecodeResult<GetClassResponse> GetClass(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Set the configuration of this serial device.
+ static ::fidl::DecodeResult<SetConfigResponse> SetConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads data from the serial port
+ static ::fidl::DecodeResult<ReadResponse> Read(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Writes data to the serial port
+ static ::fidl::DecodeResult<WriteResponse> Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = NewDevice;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetClassCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::serial::Class device_class);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::serial::Class device_class);
+ void Reply(::fidl::DecodedMessage<GetClassResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetClassCompleter = ::fidl::Completer<GetClassCompleterBase>;
+
+ virtual void GetClass(GetClassCompleter::Sync _completer) = 0;
+
+ class SetConfigCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetConfigCompleter = ::fidl::Completer<SetConfigCompleterBase>;
+
+ virtual void SetConfig(::llcpp::fuchsia::hardware::serial::Config config, SetConfigCompleter::Sync _completer) = 0;
+
+ class ReadCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::serial::NewDevice_Read_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> data);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::serial::NewDevice_Read_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<ReadResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadCompleter = ::fidl::Completer<ReadCompleterBase>;
+
+ virtual void Read(ReadCompleter::Sync _completer) = 0;
+
+ class WriteCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::serial::NewDevice_Write_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::serial::NewDevice_Write_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<WriteResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteCompleter = ::fidl::Completer<WriteCompleterBase>;
+
+ virtual void Write(::fidl::VectorView<uint8_t> data, WriteCompleter::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 GetClassRequest(const ::fidl::DecodedMessage<NewDevice::GetClassRequest>& _msg);
+ static void GetClassResponse(const ::fidl::DecodedMessage<NewDevice::GetClassResponse>& _msg);
+ static void SetConfigRequest(const ::fidl::DecodedMessage<NewDevice::SetConfigRequest>& _msg);
+ static void SetConfigResponse(const ::fidl::DecodedMessage<NewDevice::SetConfigResponse>& _msg);
+ static void ReadRequest(const ::fidl::DecodedMessage<NewDevice::ReadRequest>& _msg);
+ static void ReadResponse(const ::fidl::DecodedMessage<NewDevice::ReadResponse>& _msg);
+ static void WriteRequest(const ::fidl::DecodedMessage<NewDevice::WriteRequest>& _msg);
+ static void WriteResponse(const ::fidl::DecodedMessage<NewDevice::WriteResponse>& _msg);
+ };
+};
+
+} // namespace serial
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDeviceProxy::GetChannelRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::NewDeviceProxy::GetChannelRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDeviceProxy::GetChannelRequest)
+ == ::llcpp::fuchsia::hardware::serial::NewDeviceProxy::GetChannelRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDeviceProxy::GetChannelRequest, req) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response) == ::llcpp::fuchsia::hardware::serial::NewDevice_Write_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice_Write_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::serial::NewDevice_Write_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response, data) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response) == ::llcpp::fuchsia::hardware::serial::NewDevice_Read_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice_Read_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::serial::NewDevice_Read_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::Config> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::serial::Config>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::Config, character_width) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::Config, stop_width) == 1);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::Config, parity) == 2);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::Config, control_flow) == 3);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::Config, baud_rate) == 4);
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::Config) == ::llcpp::fuchsia::hardware::serial::Config::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::Device::GetClassResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::Device::GetClassResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::Device::GetClassResponse)
+ == ::llcpp::fuchsia::hardware::serial::Device::GetClassResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::Device::GetClassResponse, device_class) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::Device::SetConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::Device::SetConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::Device::SetConfigRequest)
+ == ::llcpp::fuchsia::hardware::serial::Device::SetConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::Device::SetConfigRequest, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::Device::SetConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::Device::SetConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::Device::SetConfigResponse)
+ == ::llcpp::fuchsia::hardware::serial::Device::SetConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::Device::SetConfigResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice::GetClassResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::NewDevice::GetClassResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDevice::GetClassResponse)
+ == ::llcpp::fuchsia::hardware::serial::NewDevice::GetClassResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDevice::GetClassResponse, device_class) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigRequest)
+ == ::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigRequest, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigResponse)
+ == ::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDevice::SetConfigResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice::ReadResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::NewDevice::ReadResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDevice::ReadResponse)
+ == ::llcpp::fuchsia::hardware::serial::NewDevice::ReadResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDevice::ReadResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice::WriteRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::NewDevice::WriteRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDevice::WriteRequest)
+ == ::llcpp::fuchsia::hardware::serial::NewDevice::WriteRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDevice::WriteRequest, data) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::serial::NewDevice::WriteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::serial::NewDevice::WriteResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::serial::NewDevice::WriteResponse)
+ == ::llcpp::fuchsia::hardware::serial::NewDevice::WriteResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::serial::NewDevice::WriteResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-skipblock/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-skipblock/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..a67e8f25
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-skipblock/gen/llcpp/fidl.cc
@@ -0,0 +1,558 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/skipblock/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace skipblock {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kSkipBlock_GetPartitionInfo_Ordinal = 0x61812f6e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSkipBlock_GetPartitionInfo_GenOrdinal = 0xf95442de92af21dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockGetPartitionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockGetPartitionInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSkipBlock_Read_Ordinal = 0x68e3be6200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSkipBlock_Read_GenOrdinal = 0x28fdd003439e980lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockReadResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSkipBlock_Write_Ordinal = 0x697d770a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSkipBlock_Write_GenOrdinal = 0x36b3b73dc0b576c8lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockWriteResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSkipBlock_WriteBytes_Ordinal = 0x4ce2ddf400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSkipBlock_WriteBytes_GenOrdinal = 0x6e1f96cd22fd1c2dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockWriteBytesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockWriteBytesResponseTable;
+
+} // namespace
+template <>
+SkipBlock::ResultOf::GetPartitionInfo_Impl<SkipBlock::GetPartitionInfoResponse>::GetPartitionInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPartitionInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPartitionInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPartitionInfoRequest));
+ ::fidl::DecodedMessage<GetPartitionInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SkipBlock::InPlace::GetPartitionInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+SkipBlock::ResultOf::GetPartitionInfo SkipBlock::SyncClient::GetPartitionInfo() {
+ return ResultOf::GetPartitionInfo(::zx::unowned_channel(this->channel_));
+}
+
+SkipBlock::ResultOf::GetPartitionInfo SkipBlock::Call::GetPartitionInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetPartitionInfo(std::move(_client_end));
+}
+
+template <>
+SkipBlock::UnownedResultOf::GetPartitionInfo_Impl<SkipBlock::GetPartitionInfoResponse>::GetPartitionInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPartitionInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPartitionInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPartitionInfoRequest));
+ ::fidl::DecodedMessage<GetPartitionInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SkipBlock::InPlace::GetPartitionInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+SkipBlock::UnownedResultOf::GetPartitionInfo SkipBlock::SyncClient::GetPartitionInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPartitionInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+SkipBlock::UnownedResultOf::GetPartitionInfo SkipBlock::Call::GetPartitionInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPartitionInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SkipBlock::GetPartitionInfoResponse> SkipBlock::InPlace::GetPartitionInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPartitionInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPartitionInfoRequest> params(std::move(_request_buffer));
+ SkipBlock::SetTransactionHeaderFor::GetPartitionInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SkipBlock::GetPartitionInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPartitionInfoRequest, GetPartitionInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SkipBlock::GetPartitionInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+SkipBlock::ResultOf::Read_Impl<SkipBlock::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_write_bytes);
+ _request.op = std::move(op);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SkipBlock::InPlace::Read(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+SkipBlock::ResultOf::Read SkipBlock::SyncClient::Read(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op) {
+ return ResultOf::Read(::zx::unowned_channel(this->channel_), std::move(op));
+}
+
+SkipBlock::ResultOf::Read SkipBlock::Call::Read(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op) {
+ return ResultOf::Read(std::move(_client_end), std::move(op));
+}
+
+template <>
+SkipBlock::UnownedResultOf::Read_Impl<SkipBlock::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_request_buffer.data());
+ _request.op = std::move(op);
+ _request_buffer.set_actual(sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SkipBlock::InPlace::Read(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+SkipBlock::UnownedResultOf::Read SkipBlock::SyncClient::Read(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(op), std::move(_response_buffer));
+}
+
+SkipBlock::UnownedResultOf::Read SkipBlock::Call::Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(std::move(_client_end), std::move(_request_buffer), std::move(op), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SkipBlock::ReadResponse> SkipBlock::InPlace::Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer) {
+ SkipBlock::SetTransactionHeaderFor::ReadRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SkipBlock::ReadResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadRequest, ReadResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SkipBlock::ReadResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+SkipBlock::ResultOf::Write_Impl<SkipBlock::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WriteRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteRequest*>(_write_bytes);
+ _request.op = std::move(op);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteRequest));
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SkipBlock::InPlace::Write(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+SkipBlock::ResultOf::Write SkipBlock::SyncClient::Write(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op) {
+ return ResultOf::Write(::zx::unowned_channel(this->channel_), std::move(op));
+}
+
+SkipBlock::ResultOf::Write SkipBlock::Call::Write(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op) {
+ return ResultOf::Write(std::move(_client_end), std::move(op));
+}
+
+template <>
+SkipBlock::UnownedResultOf::Write_Impl<SkipBlock::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WriteRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteRequest*>(_request_buffer.data());
+ _request.op = std::move(op);
+ _request_buffer.set_actual(sizeof(WriteRequest));
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SkipBlock::InPlace::Write(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+SkipBlock::UnownedResultOf::Write SkipBlock::SyncClient::Write(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(op), std::move(_response_buffer));
+}
+
+SkipBlock::UnownedResultOf::Write SkipBlock::Call::Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(std::move(_client_end), std::move(_request_buffer), std::move(op), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SkipBlock::WriteResponse> SkipBlock::InPlace::Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer) {
+ SkipBlock::SetTransactionHeaderFor::WriteRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SkipBlock::WriteResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SkipBlock::WriteResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+SkipBlock::ResultOf::WriteBytes_Impl<SkipBlock::WriteBytesResponse>::WriteBytes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteBytesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WriteBytesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteBytesRequest*>(_write_bytes);
+ _request.op = std::move(op);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteBytesRequest));
+ ::fidl::DecodedMessage<WriteBytesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SkipBlock::InPlace::WriteBytes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+SkipBlock::ResultOf::WriteBytes SkipBlock::SyncClient::WriteBytes(::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op) {
+ return ResultOf::WriteBytes(::zx::unowned_channel(this->channel_), std::move(op));
+}
+
+SkipBlock::ResultOf::WriteBytes SkipBlock::Call::WriteBytes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op) {
+ return ResultOf::WriteBytes(std::move(_client_end), std::move(op));
+}
+
+template <>
+SkipBlock::UnownedResultOf::WriteBytes_Impl<SkipBlock::WriteBytesResponse>::WriteBytes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteBytesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteBytesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WriteBytesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteBytesRequest*>(_request_buffer.data());
+ _request.op = std::move(op);
+ _request_buffer.set_actual(sizeof(WriteBytesRequest));
+ ::fidl::DecodedMessage<WriteBytesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SkipBlock::InPlace::WriteBytes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+SkipBlock::UnownedResultOf::WriteBytes SkipBlock::SyncClient::WriteBytes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteBytes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(op), std::move(_response_buffer));
+}
+
+SkipBlock::UnownedResultOf::WriteBytes SkipBlock::Call::WriteBytes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteBytes(std::move(_client_end), std::move(_request_buffer), std::move(op), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SkipBlock::WriteBytesResponse> SkipBlock::InPlace::WriteBytes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteBytesRequest> params, ::fidl::BytePart response_buffer) {
+ SkipBlock::SetTransactionHeaderFor::WriteBytesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SkipBlock::WriteBytesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteBytesRequest, WriteBytesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SkipBlock::WriteBytesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool SkipBlock::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kSkipBlock_GetPartitionInfo_Ordinal:
+ case kSkipBlock_GetPartitionInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPartitionInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetPartitionInfo(
+ Interface::GetPartitionInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kSkipBlock_Read_Ordinal:
+ case kSkipBlock_Read_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Read(std::move(message->op),
+ Interface::ReadCompleter::Sync(txn));
+ return true;
+ }
+ case kSkipBlock_Write_Ordinal:
+ case kSkipBlock_Write_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Write(std::move(message->op),
+ Interface::WriteCompleter::Sync(txn));
+ return true;
+ }
+ case kSkipBlock_WriteBytes_Ordinal:
+ case kSkipBlock_WriteBytes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteBytesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteBytes(std::move(message->op),
+ Interface::WriteBytesCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool SkipBlock::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void SkipBlock::Interface::GetPartitionInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::skipblock::PartitionInfo partition_info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPartitionInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetPartitionInfoResponse*>(_write_bytes);
+ SkipBlock::SetTransactionHeaderFor::GetPartitionInfoResponse(
+ ::fidl::DecodedMessage<GetPartitionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPartitionInfoResponse::PrimarySize,
+ GetPartitionInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.partition_info = std::move(partition_info);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPartitionInfoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetPartitionInfoResponse>(std::move(_response_bytes)));
+}
+
+void SkipBlock::Interface::GetPartitionInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::skipblock::PartitionInfo partition_info) {
+ if (_buffer.capacity() < GetPartitionInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetPartitionInfoResponse*>(_buffer.data());
+ SkipBlock::SetTransactionHeaderFor::GetPartitionInfoResponse(
+ ::fidl::DecodedMessage<GetPartitionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPartitionInfoResponse::PrimarySize,
+ GetPartitionInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.partition_info = std::move(partition_info);
+ _buffer.set_actual(sizeof(GetPartitionInfoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetPartitionInfoResponse>(std::move(_buffer)));
+}
+
+void SkipBlock::Interface::GetPartitionInfoCompleterBase::Reply(::fidl::DecodedMessage<GetPartitionInfoResponse> params) {
+ SkipBlock::SetTransactionHeaderFor::GetPartitionInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void SkipBlock::Interface::ReadCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ReadResponse*>(_write_bytes);
+ SkipBlock::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ReadResponse>(std::move(_response_bytes)));
+}
+
+void SkipBlock::Interface::ReadCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ReadResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ReadResponse*>(_buffer.data());
+ SkipBlock::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ReadResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ReadResponse>(std::move(_buffer)));
+}
+
+void SkipBlock::Interface::ReadCompleterBase::Reply(::fidl::DecodedMessage<ReadResponse> params) {
+ SkipBlock::SetTransactionHeaderFor::ReadResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void SkipBlock::Interface::WriteCompleterBase::Reply(int32_t status, bool bad_block_grown) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteResponse*>(_write_bytes);
+ SkipBlock::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.bad_block_grown = std::move(bad_block_grown);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteResponse>(std::move(_response_bytes)));
+}
+
+void SkipBlock::Interface::WriteCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, bool bad_block_grown) {
+ if (_buffer.capacity() < WriteResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteResponse*>(_buffer.data());
+ SkipBlock::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.bad_block_grown = std::move(bad_block_grown);
+ _buffer.set_actual(sizeof(WriteResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteResponse>(std::move(_buffer)));
+}
+
+void SkipBlock::Interface::WriteCompleterBase::Reply(::fidl::DecodedMessage<WriteResponse> params) {
+ SkipBlock::SetTransactionHeaderFor::WriteResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void SkipBlock::Interface::WriteBytesCompleterBase::Reply(int32_t status, bool bad_block_grown) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteBytesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteBytesResponse*>(_write_bytes);
+ SkipBlock::SetTransactionHeaderFor::WriteBytesResponse(
+ ::fidl::DecodedMessage<WriteBytesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteBytesResponse::PrimarySize,
+ WriteBytesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.bad_block_grown = std::move(bad_block_grown);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteBytesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteBytesResponse>(std::move(_response_bytes)));
+}
+
+void SkipBlock::Interface::WriteBytesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, bool bad_block_grown) {
+ if (_buffer.capacity() < WriteBytesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteBytesResponse*>(_buffer.data());
+ SkipBlock::SetTransactionHeaderFor::WriteBytesResponse(
+ ::fidl::DecodedMessage<WriteBytesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteBytesResponse::PrimarySize,
+ WriteBytesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.bad_block_grown = std::move(bad_block_grown);
+ _buffer.set_actual(sizeof(WriteBytesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteBytesResponse>(std::move(_buffer)));
+}
+
+void SkipBlock::Interface::WriteBytesCompleterBase::Reply(::fidl::DecodedMessage<WriteBytesResponse> params) {
+ SkipBlock::SetTransactionHeaderFor::WriteBytesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void SkipBlock::SetTransactionHeaderFor::GetPartitionInfoRequest(const ::fidl::DecodedMessage<SkipBlock::GetPartitionInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSkipBlock_GetPartitionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SkipBlock::SetTransactionHeaderFor::GetPartitionInfoResponse(const ::fidl::DecodedMessage<SkipBlock::GetPartitionInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSkipBlock_GetPartitionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void SkipBlock::SetTransactionHeaderFor::ReadRequest(const ::fidl::DecodedMessage<SkipBlock::ReadRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSkipBlock_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SkipBlock::SetTransactionHeaderFor::ReadResponse(const ::fidl::DecodedMessage<SkipBlock::ReadResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSkipBlock_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void SkipBlock::SetTransactionHeaderFor::WriteRequest(const ::fidl::DecodedMessage<SkipBlock::WriteRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSkipBlock_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SkipBlock::SetTransactionHeaderFor::WriteResponse(const ::fidl::DecodedMessage<SkipBlock::WriteResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSkipBlock_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void SkipBlock::SetTransactionHeaderFor::WriteBytesRequest(const ::fidl::DecodedMessage<SkipBlock::WriteBytesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSkipBlock_WriteBytes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SkipBlock::SetTransactionHeaderFor::WriteBytesResponse(const ::fidl::DecodedMessage<SkipBlock::WriteBytesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSkipBlock_WriteBytes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace skipblock
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-skipblock/gen/llcpp/include/fuchsia/hardware/skipblock/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-skipblock/gen/llcpp/include/fuchsia/hardware/skipblock/llcpp/fidl.h
new file mode 100644
index 0000000..fe045d4
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-skipblock/gen/llcpp/include/fuchsia/hardware/skipblock/llcpp/fidl.h
@@ -0,0 +1,779 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace skipblock {
+
+struct WriteBytesOperation;
+struct ReadWriteOperation;
+struct PartitionInfo;
+class SkipBlock;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_WriteBytesOperationTable;
+
+struct WriteBytesOperation {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_WriteBytesOperationTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Memory object describing buffer to write from.
+ ::zx::vmo vmo = {};
+
+ // VMO offset in bytes.
+ uint64_t vmo_offset = {};
+
+ // Device offset in bytes to begin operation from.
+ // Must be flash page aligned.
+ uint64_t offset = {};
+
+ // Number of bytes to write.
+ // Must be flash page aligned.
+ uint64_t size = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_ReadWriteOperationTable;
+
+struct ReadWriteOperation {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_ReadWriteOperationTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Memory object describing buffer to read into or write from.
+ ::zx::vmo vmo = {};
+
+ // VMO offset in bytes.
+ uint64_t vmo_offset = {};
+
+ // Block # to begin operation from.
+ uint32_t block = {};
+
+ // Number of blocks to read or write.
+ uint32_t block_count = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_PartitionInfoTable;
+
+struct PartitionInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_PartitionInfoTable;
+ 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;
+
+ // Partition type GUID.
+ ::fidl::Array<uint8_t, 16> partition_guid = {};
+
+ // Describes the read/write size.
+ uint64_t block_size_bytes = {};
+
+ // Describes size of partition in terms of blocks.
+ uint32_t partition_block_count = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockGetPartitionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockGetPartitionInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockReadResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockWriteResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockWriteBytesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_skipblock_SkipBlockWriteBytesResponseTable;
+
+class SkipBlock final {
+ SkipBlock() = delete;
+ public:
+
+ struct GetPartitionInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::hardware::skipblock::PartitionInfo partition_info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_SkipBlockGetPartitionInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ 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 GetPartitionInfoRequest = ::fidl::AnyZeroArgMessage;
+
+ struct ReadResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_SkipBlockReadResponseTable;
+ 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 ReadRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_SkipBlockReadRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = ReadResponse;
+ };
+
+ struct WriteResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ bool bad_block_grown;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_SkipBlockWriteResponseTable;
+ 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 WriteRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_SkipBlockWriteRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = WriteResponse;
+ };
+
+ struct WriteBytesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ bool bad_block_grown;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_SkipBlockWriteBytesResponseTable;
+ 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 WriteBytesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_skipblock_SkipBlockWriteBytesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = WriteBytesResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetPartitionInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetPartitionInfo_Impl(::zx::unowned_channel _client_end);
+ ~GetPartitionInfo_Impl() = default;
+ GetPartitionInfo_Impl(GetPartitionInfo_Impl&& other) = default;
+ GetPartitionInfo_Impl& operator=(GetPartitionInfo_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 Read_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 Write_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 WriteBytes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteBytes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op);
+ ~WriteBytes_Impl() = default;
+ WriteBytes_Impl(WriteBytes_Impl&& other) = default;
+ WriteBytes_Impl& operator=(WriteBytes_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 GetPartitionInfo = GetPartitionInfo_Impl<GetPartitionInfoResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using WriteBytes = WriteBytes_Impl<WriteBytesResponse>;
+ };
+
+ // 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 GetPartitionInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetPartitionInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetPartitionInfo_Impl() = default;
+ GetPartitionInfo_Impl(GetPartitionInfo_Impl&& other) = default;
+ GetPartitionInfo_Impl& operator=(GetPartitionInfo_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 Read_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 Write_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 WriteBytes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteBytes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op, ::fidl::BytePart _response_buffer);
+ ~WriteBytes_Impl() = default;
+ WriteBytes_Impl(WriteBytes_Impl&& other) = default;
+ WriteBytes_Impl& operator=(WriteBytes_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 GetPartitionInfo = GetPartitionInfo_Impl<GetPartitionInfoResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using WriteBytes = WriteBytes_Impl<WriteBytesResponse>;
+ };
+
+ 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_; }
+
+ // Returns information about the skip-block partition.
+ //
+ // The block count can shrink in the event that a bad block is grown. It is
+ // recommended to call this again after a bad block is grown.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetPartitionInfo GetPartitionInfo();
+
+ // Returns information about the skip-block partition.
+ //
+ // The block count can shrink in the event that a bad block is grown. It is
+ // recommended to call this again after a bad block is grown.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetPartitionInfo GetPartitionInfo(::fidl::BytePart _response_buffer);
+
+ // Reads the specified blocks into the provided vmo.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Read Read(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op);
+
+ // Reads the specified blocks into the provided vmo.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Read Read(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer);
+
+ // Erases and writes the specified blocks from the provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Write Write(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op);
+
+ // Erases and writes the specified blocks from the provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Write Write(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer);
+
+ // Erases and writes the specified bytes from the provided vmo. If offset
+ // and size in |op| are not aligned to |block_size_bytes| then the driver will
+ // first read the partitially written blocks and combine them with the
+ // provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WriteBytes WriteBytes(::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op);
+
+ // Erases and writes the specified bytes from the provided vmo. If offset
+ // and size in |op| are not aligned to |block_size_bytes| then the driver will
+ // first read the partitially written blocks and combine them with the
+ // provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteBytes WriteBytes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op, ::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:
+
+ // Returns information about the skip-block partition.
+ //
+ // The block count can shrink in the event that a bad block is grown. It is
+ // recommended to call this again after a bad block is grown.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetPartitionInfo GetPartitionInfo(::zx::unowned_channel _client_end);
+
+ // Returns information about the skip-block partition.
+ //
+ // The block count can shrink in the event that a bad block is grown. It is
+ // recommended to call this again after a bad block is grown.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetPartitionInfo GetPartitionInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Reads the specified blocks into the provided vmo.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Read Read(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op);
+
+ // Reads the specified blocks into the provided vmo.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Read Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer);
+
+ // Erases and writes the specified blocks from the provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Write Write(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op);
+
+ // Erases and writes the specified blocks from the provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ::fidl::BytePart _response_buffer);
+
+ // Erases and writes the specified bytes from the provided vmo. If offset
+ // and size in |op| are not aligned to |block_size_bytes| then the driver will
+ // first read the partitially written blocks and combine them with the
+ // provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WriteBytes WriteBytes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op);
+
+ // Erases and writes the specified bytes from the provided vmo. If offset
+ // and size in |op| are not aligned to |block_size_bytes| then the driver will
+ // first read the partitially written blocks and combine them with the
+ // provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteBytes WriteBytes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op, ::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:
+
+ // Returns information about the skip-block partition.
+ //
+ // The block count can shrink in the event that a bad block is grown. It is
+ // recommended to call this again after a bad block is grown.
+ static ::fidl::DecodeResult<GetPartitionInfoResponse> GetPartitionInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Reads the specified blocks into the provided vmo.
+ static ::fidl::DecodeResult<ReadResponse> Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer);
+
+ // Erases and writes the specified blocks from the provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ static ::fidl::DecodeResult<WriteResponse> Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer);
+
+ // Erases and writes the specified bytes from the provided vmo. If offset
+ // and size in |op| are not aligned to |block_size_bytes| then the driver will
+ // first read the partitially written blocks and combine them with the
+ // provided vmo.
+ //
+ // In the event that bad block is grown, the partition will shrink and
+ // `bad_block_grown` will be set to true. Since this causes the logical to
+ // physical block map to change, all previously written blocks at logical
+ // addresses after the section being written should be considered corrupted,
+ // and rewritten if applicable.
+ static ::fidl::DecodeResult<WriteBytesResponse> WriteBytes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteBytesRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = SkipBlock;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetPartitionInfoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::hardware::skipblock::PartitionInfo partition_info);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::skipblock::PartitionInfo partition_info);
+ void Reply(::fidl::DecodedMessage<GetPartitionInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPartitionInfoCompleter = ::fidl::Completer<GetPartitionInfoCompleterBase>;
+
+ virtual void GetPartitionInfo(GetPartitionInfoCompleter::Sync _completer) = 0;
+
+ class ReadCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ReadResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadCompleter = ::fidl::Completer<ReadCompleterBase>;
+
+ virtual void Read(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, ReadCompleter::Sync _completer) = 0;
+
+ class WriteCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, bool bad_block_grown);
+ void Reply(::fidl::BytePart _buffer, int32_t status, bool bad_block_grown);
+ void Reply(::fidl::DecodedMessage<WriteResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteCompleter = ::fidl::Completer<WriteCompleterBase>;
+
+ virtual void Write(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation op, WriteCompleter::Sync _completer) = 0;
+
+ class WriteBytesCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, bool bad_block_grown);
+ void Reply(::fidl::BytePart _buffer, int32_t status, bool bad_block_grown);
+ void Reply(::fidl::DecodedMessage<WriteBytesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteBytesCompleter = ::fidl::Completer<WriteBytesCompleterBase>;
+
+ virtual void WriteBytes(::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation op, WriteBytesCompleter::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 GetPartitionInfoRequest(const ::fidl::DecodedMessage<SkipBlock::GetPartitionInfoRequest>& _msg);
+ static void GetPartitionInfoResponse(const ::fidl::DecodedMessage<SkipBlock::GetPartitionInfoResponse>& _msg);
+ static void ReadRequest(const ::fidl::DecodedMessage<SkipBlock::ReadRequest>& _msg);
+ static void ReadResponse(const ::fidl::DecodedMessage<SkipBlock::ReadResponse>& _msg);
+ static void WriteRequest(const ::fidl::DecodedMessage<SkipBlock::WriteRequest>& _msg);
+ static void WriteResponse(const ::fidl::DecodedMessage<SkipBlock::WriteResponse>& _msg);
+ static void WriteBytesRequest(const ::fidl::DecodedMessage<SkipBlock::WriteBytesRequest>& _msg);
+ static void WriteBytesResponse(const ::fidl::DecodedMessage<SkipBlock::WriteBytesResponse>& _msg);
+ };
+};
+
+constexpr uint32_t GUID_LEN = 16u;
+
+} // namespace skipblock
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation, vmo) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation, vmo_offset) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation, offset) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation, size) == 24);
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation) == ::llcpp::fuchsia::hardware::skipblock::WriteBytesOperation::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation, vmo) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation, vmo_offset) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation, block) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation, block_count) == 20);
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation) == ::llcpp::fuchsia::hardware::skipblock::ReadWriteOperation::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::PartitionInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::skipblock::PartitionInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::PartitionInfo, partition_guid) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::PartitionInfo, block_size_bytes) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::PartitionInfo, partition_block_count) == 24);
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::PartitionInfo) == ::llcpp::fuchsia::hardware::skipblock::PartitionInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::SkipBlock::GetPartitionInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::skipblock::SkipBlock::GetPartitionInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::GetPartitionInfoResponse)
+ == ::llcpp::fuchsia::hardware::skipblock::SkipBlock::GetPartitionInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::GetPartitionInfoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::GetPartitionInfoResponse, partition_info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadRequest)
+ == ::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadRequest, op) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadResponse)
+ == ::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::ReadResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteRequest)
+ == ::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteRequest, op) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteResponse)
+ == ::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteResponse, bad_block_grown) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesRequest)
+ == ::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesRequest, op) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesResponse)
+ == ::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::skipblock::SkipBlock::WriteBytesResponse, bad_block_grown) == 20);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-spi/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-spi/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..5d65012
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-spi/gen/llcpp/fidl.cc
@@ -0,0 +1,462 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/spi/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace spi {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_Transmit_Ordinal = 0x589d02df00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Transmit_GenOrdinal = 0x5fdb4f4f36a3efd2lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceTransmitRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceTransmitResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Receive_Ordinal = 0x58529d900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Receive_GenOrdinal = 0x2327a558210150b1lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceReceiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceReceiveResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Exchange_Ordinal = 0x13c3394e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_Exchange_GenOrdinal = 0x5661a0cef18dd908lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceExchangeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceExchangeResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::Transmit_Impl<Device::TransmitResponse>::Transmit_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TransmitRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ TransmitRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<TransmitRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::Transmit(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::Transmit Device::SyncClient::Transmit(::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Transmit(::zx::unowned_channel(this->channel_), std::move(data));
+}
+
+Device::ResultOf::Transmit Device::Call::Transmit(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Transmit(std::move(_client_end), std::move(data));
+}
+
+template <>
+Device::UnownedResultOf::Transmit_Impl<Device::TransmitResponse>::Transmit_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < TransmitRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<TransmitResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ TransmitRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<TransmitRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::Transmit(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Transmit Device::SyncClient::Transmit(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Transmit(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Transmit Device::Call::Transmit(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Transmit(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::TransmitResponse> Device::InPlace::Transmit(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TransmitRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::TransmitRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::TransmitResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<TransmitRequest, TransmitResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::TransmitResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Receive_Impl<Device::ReceiveResponse>::Receive_Impl(::zx::unowned_channel _client_end, uint32_t size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReceiveRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReceiveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReceiveRequest*>(_write_bytes);
+ _request.size = std::move(size);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReceiveRequest));
+ ::fidl::DecodedMessage<ReceiveRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::Receive(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::Receive Device::SyncClient::Receive(uint32_t size) {
+ return ResultOf::Receive(::zx::unowned_channel(this->channel_), std::move(size));
+}
+
+Device::ResultOf::Receive Device::Call::Receive(::zx::unowned_channel _client_end, uint32_t size) {
+ return ResultOf::Receive(std::move(_client_end), std::move(size));
+}
+
+template <>
+Device::UnownedResultOf::Receive_Impl<Device::ReceiveResponse>::Receive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t size, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReceiveRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReceiveResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReceiveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReceiveRequest*>(_request_buffer.data());
+ _request.size = std::move(size);
+ _request_buffer.set_actual(sizeof(ReceiveRequest));
+ ::fidl::DecodedMessage<ReceiveRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::Receive(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Receive Device::SyncClient::Receive(::fidl::BytePart _request_buffer, uint32_t size, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Receive(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(size), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Receive Device::Call::Receive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t size, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Receive(std::move(_client_end), std::move(_request_buffer), std::move(size), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ReceiveResponse> Device::InPlace::Receive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReceiveRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::ReceiveRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ReceiveResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReceiveRequest, ReceiveResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ReceiveResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::Exchange_Impl<Device::ExchangeResponse>::Exchange_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> txdata) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ExchangeRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ ExchangeRequest _request = {};
+ _request.txdata = std::move(txdata);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ExchangeRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::Exchange(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::Exchange Device::SyncClient::Exchange(::fidl::VectorView<uint8_t> txdata) {
+ return ResultOf::Exchange(::zx::unowned_channel(this->channel_), std::move(txdata));
+}
+
+Device::ResultOf::Exchange Device::Call::Exchange(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> txdata) {
+ return ResultOf::Exchange(std::move(_client_end), std::move(txdata));
+}
+
+template <>
+Device::UnownedResultOf::Exchange_Impl<Device::ExchangeResponse>::Exchange_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> txdata, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ExchangeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ExchangeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ ExchangeRequest _request = {};
+ _request.txdata = std::move(txdata);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ExchangeRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::Exchange(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::Exchange Device::SyncClient::Exchange(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> txdata, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Exchange(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(txdata), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::Exchange Device::Call::Exchange(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> txdata, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Exchange(std::move(_client_end), std::move(_request_buffer), std::move(txdata), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::ExchangeResponse> Device::InPlace::Exchange(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ExchangeRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::ExchangeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ExchangeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ExchangeRequest, ExchangeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ExchangeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_Transmit_Ordinal:
+ case kDevice_Transmit_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<TransmitRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Transmit(std::move(message->data),
+ Interface::TransmitCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Receive_Ordinal:
+ case kDevice_Receive_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReceiveRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Receive(std::move(message->size),
+ Interface::ReceiveCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_Exchange_Ordinal:
+ case kDevice_Exchange_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ExchangeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Exchange(std::move(message->txdata),
+ Interface::ExchangeCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::TransmitCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TransmitResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<TransmitResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::TransmitResponse(
+ ::fidl::DecodedMessage<TransmitResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TransmitResponse::PrimarySize,
+ TransmitResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(TransmitResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<TransmitResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::TransmitCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < TransmitResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<TransmitResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::TransmitResponse(
+ ::fidl::DecodedMessage<TransmitResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TransmitResponse::PrimarySize,
+ TransmitResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(TransmitResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<TransmitResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::TransmitCompleterBase::Reply(::fidl::DecodedMessage<TransmitResponse> params) {
+ Device::SetTransactionHeaderFor::TransmitResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ReceiveCompleterBase::Reply(int32_t status, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReceiveResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReceiveResponse _response = {};
+ Device::SetTransactionHeaderFor::ReceiveResponse(
+ ::fidl::DecodedMessage<ReceiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReceiveResponse::PrimarySize,
+ ReceiveResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::ReceiveCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> data) {
+ if (_buffer.capacity() < ReceiveResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReceiveResponse _response = {};
+ Device::SetTransactionHeaderFor::ReceiveResponse(
+ ::fidl::DecodedMessage<ReceiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReceiveResponse::PrimarySize,
+ ReceiveResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::ReceiveCompleterBase::Reply(::fidl::DecodedMessage<ReceiveResponse> params) {
+ Device::SetTransactionHeaderFor::ReceiveResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ExchangeCompleterBase::Reply(int32_t status, ::fidl::VectorView<uint8_t> rxdata) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ExchangeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ExchangeResponse _response = {};
+ Device::SetTransactionHeaderFor::ExchangeResponse(
+ ::fidl::DecodedMessage<ExchangeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ExchangeResponse::PrimarySize,
+ ExchangeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.rxdata = std::move(rxdata);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::ExchangeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> rxdata) {
+ if (_buffer.capacity() < ExchangeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ExchangeResponse _response = {};
+ Device::SetTransactionHeaderFor::ExchangeResponse(
+ ::fidl::DecodedMessage<ExchangeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ExchangeResponse::PrimarySize,
+ ExchangeResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.rxdata = std::move(rxdata);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::ExchangeCompleterBase::Reply(::fidl::DecodedMessage<ExchangeResponse> params) {
+ Device::SetTransactionHeaderFor::ExchangeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::TransmitRequest(const ::fidl::DecodedMessage<Device::TransmitRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Transmit_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::TransmitResponse(const ::fidl::DecodedMessage<Device::TransmitResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Transmit_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ReceiveRequest(const ::fidl::DecodedMessage<Device::ReceiveRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Receive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ReceiveResponse(const ::fidl::DecodedMessage<Device::ReceiveResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Receive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ExchangeRequest(const ::fidl::DecodedMessage<Device::ExchangeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Exchange_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ExchangeResponse(const ::fidl::DecodedMessage<Device::ExchangeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_Exchange_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace spi
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-spi/gen/llcpp/include/fuchsia/hardware/spi/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-spi/gen/llcpp/include/fuchsia/hardware/spi/llcpp/fidl.h
new file mode 100644
index 0000000..6ef0df8
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-spi/gen/llcpp/include/fuchsia/hardware/spi/llcpp/fidl.h
@@ -0,0 +1,498 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace spi {
+
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceTransmitRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceTransmitResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceReceiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceReceiveResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceExchangeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_spi_DeviceExchangeResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct TransmitResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_spi_DeviceTransmitResponseTable;
+ 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 TransmitRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_spi_DeviceTransmitRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 8200;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 8200;
+ 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 = TransmitResponse;
+ };
+
+ struct ReceiveResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_spi_DeviceReceiveResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8200;
+ 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 ReceiveRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_spi_DeviceReceiveRequestTable;
+ 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 = ReceiveResponse;
+ };
+
+ struct ExchangeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::fidl::VectorView<uint8_t> rxdata;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_spi_DeviceExchangeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8200;
+ 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 ExchangeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> txdata;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_spi_DeviceExchangeRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 8200;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 8200;
+ 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 = ExchangeResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Transmit_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Transmit_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+ ~Transmit_Impl() = default;
+ Transmit_Impl(Transmit_Impl&& other) = default;
+ Transmit_Impl& operator=(Transmit_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 Receive_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Receive_Impl(::zx::unowned_channel _client_end, uint32_t size);
+ ~Receive_Impl() = default;
+ Receive_Impl(Receive_Impl&& other) = default;
+ Receive_Impl& operator=(Receive_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 Exchange_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Exchange_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> txdata);
+ ~Exchange_Impl() = default;
+ Exchange_Impl(Exchange_Impl&& other) = default;
+ Exchange_Impl& operator=(Exchange_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 Transmit = Transmit_Impl<TransmitResponse>;
+ using Receive = Receive_Impl<ReceiveResponse>;
+ using Exchange = Exchange_Impl<ExchangeResponse>;
+ };
+
+ // 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 Transmit_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Transmit_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+ ~Transmit_Impl() = default;
+ Transmit_Impl(Transmit_Impl&& other) = default;
+ Transmit_Impl& operator=(Transmit_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 Receive_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Receive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t size, ::fidl::BytePart _response_buffer);
+ ~Receive_Impl() = default;
+ Receive_Impl(Receive_Impl&& other) = default;
+ Receive_Impl& operator=(Receive_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 Exchange_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Exchange_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> txdata, ::fidl::BytePart _response_buffer);
+ ~Exchange_Impl() = default;
+ Exchange_Impl(Exchange_Impl&& other) = default;
+ Exchange_Impl& operator=(Exchange_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 Transmit = Transmit_Impl<TransmitResponse>;
+ using Receive = Receive_Impl<ReceiveResponse>;
+ using Exchange = Exchange_Impl<ExchangeResponse>;
+ };
+
+ 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_; }
+
+ // Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Transmit Transmit(::fidl::VectorView<uint8_t> data);
+
+ // Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Transmit Transmit(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Half-duplex receive data from a SPI device; always reads the full size requested.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Receive Receive(uint32_t size);
+
+ // Half-duplex receive data from a SPI device; always reads the full size requested.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Receive Receive(::fidl::BytePart _request_buffer, uint32_t size, ::fidl::BytePart _response_buffer);
+
+ // Full-duplex SPI transaction. Received data will exactly equal the length of the transmit
+ // buffer.
+ // Request is heap-allocated. Response is heap-allocated.
+ ResultOf::Exchange Exchange(::fidl::VectorView<uint8_t> txdata);
+
+ // Full-duplex SPI transaction. Received data will exactly equal the length of the transmit
+ // buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Exchange Exchange(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> txdata, ::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:
+
+ // Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Transmit Transmit(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+
+ // Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Transmit Transmit(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Half-duplex receive data from a SPI device; always reads the full size requested.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Receive Receive(::zx::unowned_channel _client_end, uint32_t size);
+
+ // Half-duplex receive data from a SPI device; always reads the full size requested.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Receive Receive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t size, ::fidl::BytePart _response_buffer);
+
+ // Full-duplex SPI transaction. Received data will exactly equal the length of the transmit
+ // buffer.
+ // Request is heap-allocated. Response is heap-allocated.
+ static ResultOf::Exchange Exchange(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> txdata);
+
+ // Full-duplex SPI transaction. Received data will exactly equal the length of the transmit
+ // buffer.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Exchange Exchange(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> txdata, ::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:
+
+ // Half-duplex transmit data to a SPI device; always transmits the entire buffer on success.
+ static ::fidl::DecodeResult<TransmitResponse> Transmit(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TransmitRequest> params, ::fidl::BytePart response_buffer);
+
+ // Half-duplex receive data from a SPI device; always reads the full size requested.
+ static ::fidl::DecodeResult<ReceiveResponse> Receive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReceiveRequest> params, ::fidl::BytePart response_buffer);
+
+ // Full-duplex SPI transaction. Received data will exactly equal the length of the transmit
+ // buffer.
+ static ::fidl::DecodeResult<ExchangeResponse> Exchange(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ExchangeRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class TransmitCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<TransmitResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using TransmitCompleter = ::fidl::Completer<TransmitCompleterBase>;
+
+ virtual void Transmit(::fidl::VectorView<uint8_t> data, TransmitCompleter::Sync _completer) = 0;
+
+ class ReceiveCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<ReceiveResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReceiveCompleter = ::fidl::Completer<ReceiveCompleterBase>;
+
+ virtual void Receive(uint32_t size, ReceiveCompleter::Sync _completer) = 0;
+
+ class ExchangeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::fidl::VectorView<uint8_t> rxdata);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::VectorView<uint8_t> rxdata);
+ void Reply(::fidl::DecodedMessage<ExchangeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ExchangeCompleter = ::fidl::Completer<ExchangeCompleterBase>;
+
+ virtual void Exchange(::fidl::VectorView<uint8_t> txdata, ExchangeCompleter::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 TransmitRequest(const ::fidl::DecodedMessage<Device::TransmitRequest>& _msg);
+ static void TransmitResponse(const ::fidl::DecodedMessage<Device::TransmitResponse>& _msg);
+ static void ReceiveRequest(const ::fidl::DecodedMessage<Device::ReceiveRequest>& _msg);
+ static void ReceiveResponse(const ::fidl::DecodedMessage<Device::ReceiveResponse>& _msg);
+ static void ExchangeRequest(const ::fidl::DecodedMessage<Device::ExchangeRequest>& _msg);
+ static void ExchangeResponse(const ::fidl::DecodedMessage<Device::ExchangeResponse>& _msg);
+ };
+};
+
+constexpr uint32_t MAX_TRANSFER_SIZE = 8196u;
+
+} // namespace spi
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::spi::Device::TransmitRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::spi::Device::TransmitRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::spi::Device::TransmitRequest)
+ == ::llcpp::fuchsia::hardware::spi::Device::TransmitRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::spi::Device::TransmitRequest, data) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::spi::Device::TransmitResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::spi::Device::TransmitResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::spi::Device::TransmitResponse)
+ == ::llcpp::fuchsia::hardware::spi::Device::TransmitResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::spi::Device::TransmitResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::spi::Device::ReceiveRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::spi::Device::ReceiveRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::spi::Device::ReceiveRequest)
+ == ::llcpp::fuchsia::hardware::spi::Device::ReceiveRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::spi::Device::ReceiveRequest, size) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::spi::Device::ReceiveResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::spi::Device::ReceiveResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::spi::Device::ReceiveResponse)
+ == ::llcpp::fuchsia::hardware::spi::Device::ReceiveResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::spi::Device::ReceiveResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::spi::Device::ReceiveResponse, data) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::spi::Device::ExchangeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::spi::Device::ExchangeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::spi::Device::ExchangeRequest)
+ == ::llcpp::fuchsia::hardware::spi::Device::ExchangeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::spi::Device::ExchangeRequest, txdata) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::spi::Device::ExchangeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::spi::Device::ExchangeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::spi::Device::ExchangeResponse)
+ == ::llcpp::fuchsia::hardware::spi::Device::ExchangeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::spi::Device::ExchangeResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::spi::Device::ExchangeResponse, rxdata) == 24);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-tee/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-tee/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..f8ed6d1
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-tee/gen/llcpp/fidl.cc
@@ -0,0 +1,139 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/tee/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace tee {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDeviceConnector_ConnectTee_Ordinal = 0x5b2280b900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDeviceConnector_ConnectTee_GenOrdinal = 0x37d7bf45f48faed6lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_tee_DeviceConnectorConnectTeeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_tee_DeviceConnectorConnectTeeResponseTable;
+
+} // namespace
+
+DeviceConnector::ResultOf::ConnectTee_Impl::ConnectTee_Impl(::zx::unowned_channel _client_end, ::zx::channel service_provider, ::zx::channel tee_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectTeeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConnectTeeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConnectTeeRequest*>(_write_bytes);
+ _request.service_provider = std::move(service_provider);
+ _request.tee_request = std::move(tee_request);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConnectTeeRequest));
+ ::fidl::DecodedMessage<ConnectTeeRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DeviceConnector::InPlace::ConnectTee(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceConnector::ResultOf::ConnectTee DeviceConnector::SyncClient::ConnectTee(::zx::channel service_provider, ::zx::channel tee_request) {
+ return ResultOf::ConnectTee(::zx::unowned_channel(this->channel_), std::move(service_provider), std::move(tee_request));
+}
+
+DeviceConnector::ResultOf::ConnectTee DeviceConnector::Call::ConnectTee(::zx::unowned_channel _client_end, ::zx::channel service_provider, ::zx::channel tee_request) {
+ return ResultOf::ConnectTee(std::move(_client_end), std::move(service_provider), std::move(tee_request));
+}
+
+
+DeviceConnector::UnownedResultOf::ConnectTee_Impl::ConnectTee_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel service_provider, ::zx::channel tee_request) {
+ if (_request_buffer.capacity() < ConnectTeeRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ConnectTeeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConnectTeeRequest*>(_request_buffer.data());
+ _request.service_provider = std::move(service_provider);
+ _request.tee_request = std::move(tee_request);
+ _request_buffer.set_actual(sizeof(ConnectTeeRequest));
+ ::fidl::DecodedMessage<ConnectTeeRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DeviceConnector::InPlace::ConnectTee(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DeviceConnector::UnownedResultOf::ConnectTee DeviceConnector::SyncClient::ConnectTee(::fidl::BytePart _request_buffer, ::zx::channel service_provider, ::zx::channel tee_request) {
+ return UnownedResultOf::ConnectTee(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(service_provider), std::move(tee_request));
+}
+
+DeviceConnector::UnownedResultOf::ConnectTee DeviceConnector::Call::ConnectTee(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel service_provider, ::zx::channel tee_request) {
+ return UnownedResultOf::ConnectTee(std::move(_client_end), std::move(_request_buffer), std::move(service_provider), std::move(tee_request));
+}
+
+::fidl::internal::StatusAndError DeviceConnector::InPlace::ConnectTee(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectTeeRequest> params) {
+ DeviceConnector::SetTransactionHeaderFor::ConnectTeeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool DeviceConnector::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDeviceConnector_ConnectTee_Ordinal:
+ case kDeviceConnector_ConnectTee_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConnectTeeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ConnectTee(std::move(message->service_provider), std::move(message->tee_request),
+ Interface::ConnectTeeCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DeviceConnector::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void DeviceConnector::SetTransactionHeaderFor::ConnectTeeRequest(const ::fidl::DecodedMessage<DeviceConnector::ConnectTeeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDeviceConnector_ConnectTee_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace tee
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-tee/gen/llcpp/include/fuchsia/hardware/tee/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-tee/gen/llcpp/include/fuchsia/hardware/tee/llcpp/fidl.h
new file mode 100644
index 0000000..76b59ce
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-tee/gen/llcpp/include/fuchsia/hardware/tee/llcpp/fidl.h
@@ -0,0 +1,221 @@
+// 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 <zircon/fidl.h>
+
+#include <fuchsia/tee/llcpp/fidl.h>
+#include <fuchsia/tee/manager/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace tee {
+
+class DeviceConnector;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_tee_DeviceConnectorConnectTeeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_tee_DeviceConnectorConnectTeeResponseTable;
+
+// Protocol used by the TEE Manager to proxy requests for TEE access to the driver.
+class DeviceConnector final {
+ DeviceConnector() = delete;
+ public:
+
+ struct ConnectTeeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel service_provider;
+ ::zx::channel tee_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_tee_DeviceConnectorConnectTeeRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class ConnectTee_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ConnectTee_Impl(::zx::unowned_channel _client_end, ::zx::channel service_provider, ::zx::channel tee_request);
+ ~ConnectTee_Impl() = default;
+ ConnectTee_Impl(ConnectTee_Impl&& other) = default;
+ ConnectTee_Impl& operator=(ConnectTee_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using ConnectTee = ConnectTee_Impl;
+ };
+
+ // 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:
+ class ConnectTee_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ ConnectTee_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel service_provider, ::zx::channel tee_request);
+ ~ConnectTee_Impl() = default;
+ ConnectTee_Impl(ConnectTee_Impl&& other) = default;
+ ConnectTee_Impl& operator=(ConnectTee_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using ConnectTee = ConnectTee_Impl;
+ };
+
+ 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_; }
+
+ // Requests service from the TEE driver while the caller provides a client end to a
+ // Provider server that supports the driver on any RPCs.
+ //
+ // The sole caller of this should be the TEE Manager.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConnectTee ConnectTee(::zx::channel service_provider, ::zx::channel tee_request);
+
+ // Requests service from the TEE driver while the caller provides a client end to a
+ // Provider server that supports the driver on any RPCs.
+ //
+ // The sole caller of this should be the TEE Manager.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConnectTee ConnectTee(::fidl::BytePart _request_buffer, ::zx::channel service_provider, ::zx::channel tee_request);
+
+ 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:
+
+ // Requests service from the TEE driver while the caller provides a client end to a
+ // Provider server that supports the driver on any RPCs.
+ //
+ // The sole caller of this should be the TEE Manager.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConnectTee ConnectTee(::zx::unowned_channel _client_end, ::zx::channel service_provider, ::zx::channel tee_request);
+
+ // Requests service from the TEE driver while the caller provides a client end to a
+ // Provider server that supports the driver on any RPCs.
+ //
+ // The sole caller of this should be the TEE Manager.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConnectTee ConnectTee(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel service_provider, ::zx::channel tee_request);
+
+ };
+
+ // 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:
+
+ // Requests service from the TEE driver while the caller provides a client end to a
+ // Provider server that supports the driver on any RPCs.
+ //
+ // The sole caller of this should be the TEE Manager.
+ static ::fidl::internal::StatusAndError ConnectTee(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectTeeRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DeviceConnector;
+ using _Base = ::fidl::CompleterBase;
+
+ using ConnectTeeCompleter = ::fidl::Completer<>;
+
+ virtual void ConnectTee(::zx::channel service_provider, ::zx::channel tee_request, ConnectTeeCompleter::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 ConnectTeeRequest(const ::fidl::DecodedMessage<DeviceConnector::ConnectTeeRequest>& _msg);
+ };
+};
+
+} // namespace tee
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::tee::DeviceConnector::ConnectTeeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::tee::DeviceConnector::ConnectTeeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::tee::DeviceConnector::ConnectTeeRequest)
+ == ::llcpp::fuchsia::hardware::tee::DeviceConnector::ConnectTeeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::tee::DeviceConnector::ConnectTeeRequest, service_provider) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::tee::DeviceConnector::ConnectTeeRequest, tee_request) == 20);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-thermal/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-thermal/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..2055080
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-thermal/gen/llcpp/fidl.cc
@@ -0,0 +1,1472 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/thermal/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace thermal {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetInfo_Ordinal = 0x337747c500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetInfo_GenOrdinal = 0x350d7a106835fbdalu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceInfo_Ordinal = 0x80abe5f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceInfo_GenOrdinal = 0x5c35349ec9cd7c79lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDeviceInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDeviceInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDvfsInfo_Ordinal = 0x6b72261200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDvfsInfo_GenOrdinal = 0xb2e9de2423e77eblu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDvfsInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDvfsInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetTemperatureCelsius_Ordinal = 0x1c4ce3b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetTemperatureCelsius_GenOrdinal = 0xb549276d89de7elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetTemperatureCelsiusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetTemperatureCelsiusResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStateChangeEvent_Ordinal = 0x981447d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStateChangeEvent_GenOrdinal = 0x3f6e614172af0a87lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetStateChangeEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetStateChangeEventResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStateChangePort_Ordinal = 0x626a7a1100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStateChangePort_GenOrdinal = 0x7eef3857e900208lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetStateChangePortRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetStateChangePortResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetTripCelsius_Ordinal = 0x1a338bd400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetTripCelsius_GenOrdinal = 0x25e3eafaa78a203elu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetTripCelsiusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetTripCelsiusResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDvfsOperatingPoint_Ordinal = 0x2725cb4400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDvfsOperatingPoint_GenOrdinal = 0x56d566ab5a9ba330lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDvfsOperatingPointRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDvfsOperatingPointResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetDvfsOperatingPoint_Ordinal = 0x553fac4700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetDvfsOperatingPoint_GenOrdinal = 0x9c2508074fe4351lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetDvfsOperatingPointRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetDvfsOperatingPointResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetFanLevel_Ordinal = 0xa3623b300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetFanLevel_GenOrdinal = 0x224636b2f864d8d6lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetFanLevelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetFanLevelResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetFanLevel_Ordinal = 0x344c3d2700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetFanLevel_GenOrdinal = 0x2dfba6aa920e901dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetFanLevelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetFanLevelResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetInfo_Impl<Device::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetInfo Device::SyncClient::GetInfo() {
+ return ResultOf::GetInfo(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetInfo Device::Call::GetInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInfo(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetInfo_Impl<Device::GetInfoResponse>::GetInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInfoRequest));
+ ::fidl::DecodedMessage<GetInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetInfo Device::SyncClient::GetInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetInfo Device::Call::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetInfoResponse> Device::InPlace::GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInfoRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInfoRequest, GetInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetDeviceInfo_Impl<Device::GetDeviceInfoResponse>::GetDeviceInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDeviceInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceInfoRequest));
+ ::fidl::DecodedMessage<GetDeviceInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetDeviceInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetDeviceInfo Device::SyncClient::GetDeviceInfo() {
+ return ResultOf::GetDeviceInfo(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetDeviceInfo Device::Call::GetDeviceInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDeviceInfo(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetDeviceInfo_Impl<Device::GetDeviceInfoResponse>::GetDeviceInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDeviceInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDeviceInfoRequest));
+ ::fidl::DecodedMessage<GetDeviceInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetDeviceInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetDeviceInfo Device::SyncClient::GetDeviceInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetDeviceInfo Device::Call::GetDeviceInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetDeviceInfoResponse> Device::InPlace::GetDeviceInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDeviceInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDeviceInfoRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetDeviceInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDeviceInfoRequest, GetDeviceInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetDvfsInfo_Impl<Device::GetDvfsInfoResponse>::GetDvfsInfo_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDvfsInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDvfsInfoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetDvfsInfoRequest*>(_write_bytes);
+ _request.power_domain = std::move(power_domain);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDvfsInfoRequest));
+ ::fidl::DecodedMessage<GetDvfsInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetDvfsInfo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetDvfsInfo Device::SyncClient::GetDvfsInfo(::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ return ResultOf::GetDvfsInfo(::zx::unowned_channel(this->channel_), std::move(power_domain));
+}
+
+Device::ResultOf::GetDvfsInfo Device::Call::GetDvfsInfo(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ return ResultOf::GetDvfsInfo(std::move(_client_end), std::move(power_domain));
+}
+
+template <>
+Device::UnownedResultOf::GetDvfsInfo_Impl<Device::GetDvfsInfoResponse>::GetDvfsInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetDvfsInfoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetDvfsInfoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetDvfsInfoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetDvfsInfoRequest*>(_request_buffer.data());
+ _request.power_domain = std::move(power_domain);
+ _request_buffer.set_actual(sizeof(GetDvfsInfoRequest));
+ ::fidl::DecodedMessage<GetDvfsInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetDvfsInfo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetDvfsInfo Device::SyncClient::GetDvfsInfo(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDvfsInfo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(power_domain), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetDvfsInfo Device::Call::GetDvfsInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDvfsInfo(std::move(_client_end), std::move(_request_buffer), std::move(power_domain), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetDvfsInfoResponse> Device::InPlace::GetDvfsInfo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetDvfsInfoRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetDvfsInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDvfsInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDvfsInfoRequest, GetDvfsInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDvfsInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetTemperatureCelsius_Impl<Device::GetTemperatureCelsiusResponse>::GetTemperatureCelsius_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTemperatureCelsiusRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTemperatureCelsiusRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTemperatureCelsiusRequest));
+ ::fidl::DecodedMessage<GetTemperatureCelsiusRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetTemperatureCelsius(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetTemperatureCelsius Device::SyncClient::GetTemperatureCelsius() {
+ return ResultOf::GetTemperatureCelsius(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetTemperatureCelsius Device::Call::GetTemperatureCelsius(::zx::unowned_channel _client_end) {
+ return ResultOf::GetTemperatureCelsius(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetTemperatureCelsius_Impl<Device::GetTemperatureCelsiusResponse>::GetTemperatureCelsius_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTemperatureCelsiusRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTemperatureCelsiusRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTemperatureCelsiusRequest));
+ ::fidl::DecodedMessage<GetTemperatureCelsiusRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetTemperatureCelsius(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetTemperatureCelsius Device::SyncClient::GetTemperatureCelsius(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTemperatureCelsius(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetTemperatureCelsius Device::Call::GetTemperatureCelsius(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetTemperatureCelsius(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetTemperatureCelsiusResponse> Device::InPlace::GetTemperatureCelsius(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTemperatureCelsiusRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTemperatureCelsiusRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetTemperatureCelsiusRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetTemperatureCelsiusResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTemperatureCelsiusRequest, GetTemperatureCelsiusResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetTemperatureCelsiusResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetStateChangeEvent_Impl<Device::GetStateChangeEventResponse>::GetStateChangeEvent_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateChangeEventRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStateChangeEventRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStateChangeEventRequest));
+ ::fidl::DecodedMessage<GetStateChangeEventRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetStateChangeEvent(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetStateChangeEvent Device::SyncClient::GetStateChangeEvent() {
+ return ResultOf::GetStateChangeEvent(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetStateChangeEvent Device::Call::GetStateChangeEvent(::zx::unowned_channel _client_end) {
+ return ResultOf::GetStateChangeEvent(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetStateChangeEvent_Impl<Device::GetStateChangeEventResponse>::GetStateChangeEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetStateChangeEventRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetStateChangeEventRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetStateChangeEventRequest));
+ ::fidl::DecodedMessage<GetStateChangeEventRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetStateChangeEvent(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetStateChangeEvent Device::SyncClient::GetStateChangeEvent(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStateChangeEvent(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetStateChangeEvent Device::Call::GetStateChangeEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStateChangeEvent(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetStateChangeEventResponse> Device::InPlace::GetStateChangeEvent(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetStateChangeEventRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetStateChangeEventRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetStateChangeEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStateChangeEventResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStateChangeEventRequest, GetStateChangeEventResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStateChangeEventResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetStateChangePort_Impl<Device::GetStateChangePortResponse>::GetStateChangePort_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateChangePortRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStateChangePortRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStateChangePortRequest));
+ ::fidl::DecodedMessage<GetStateChangePortRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetStateChangePort(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetStateChangePort Device::SyncClient::GetStateChangePort() {
+ return ResultOf::GetStateChangePort(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetStateChangePort Device::Call::GetStateChangePort(::zx::unowned_channel _client_end) {
+ return ResultOf::GetStateChangePort(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetStateChangePort_Impl<Device::GetStateChangePortResponse>::GetStateChangePort_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetStateChangePortRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetStateChangePortRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetStateChangePortRequest));
+ ::fidl::DecodedMessage<GetStateChangePortRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetStateChangePort(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetStateChangePort Device::SyncClient::GetStateChangePort(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStateChangePort(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetStateChangePort Device::Call::GetStateChangePort(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStateChangePort(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetStateChangePortResponse> Device::InPlace::GetStateChangePort(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetStateChangePortRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetStateChangePortRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetStateChangePortRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStateChangePortResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStateChangePortRequest, GetStateChangePortResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStateChangePortResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetTripCelsius_Impl<Device::SetTripCelsiusResponse>::SetTripCelsius_Impl(::zx::unowned_channel _client_end, uint32_t id, float temp) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTripCelsiusRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetTripCelsiusRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetTripCelsiusRequest*>(_write_bytes);
+ _request.id = std::move(id);
+ _request.temp = std::move(temp);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTripCelsiusRequest));
+ ::fidl::DecodedMessage<SetTripCelsiusRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetTripCelsius(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetTripCelsius Device::SyncClient::SetTripCelsius(uint32_t id, float temp) {
+ return ResultOf::SetTripCelsius(::zx::unowned_channel(this->channel_), std::move(id), std::move(temp));
+}
+
+Device::ResultOf::SetTripCelsius Device::Call::SetTripCelsius(::zx::unowned_channel _client_end, uint32_t id, float temp) {
+ return ResultOf::SetTripCelsius(std::move(_client_end), std::move(id), std::move(temp));
+}
+
+template <>
+Device::UnownedResultOf::SetTripCelsius_Impl<Device::SetTripCelsiusResponse>::SetTripCelsius_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, float temp, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetTripCelsiusRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetTripCelsiusResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetTripCelsiusRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetTripCelsiusRequest*>(_request_buffer.data());
+ _request.id = std::move(id);
+ _request.temp = std::move(temp);
+ _request_buffer.set_actual(sizeof(SetTripCelsiusRequest));
+ ::fidl::DecodedMessage<SetTripCelsiusRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetTripCelsius(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetTripCelsius Device::SyncClient::SetTripCelsius(::fidl::BytePart _request_buffer, uint32_t id, float temp, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetTripCelsius(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(id), std::move(temp), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetTripCelsius Device::Call::SetTripCelsius(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, float temp, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetTripCelsius(std::move(_client_end), std::move(_request_buffer), std::move(id), std::move(temp), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetTripCelsiusResponse> Device::InPlace::SetTripCelsius(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTripCelsiusRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetTripCelsiusRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetTripCelsiusResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetTripCelsiusRequest, SetTripCelsiusResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetTripCelsiusResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetDvfsOperatingPoint_Impl<Device::GetDvfsOperatingPointResponse>::GetDvfsOperatingPoint_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDvfsOperatingPointRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDvfsOperatingPointRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetDvfsOperatingPointRequest*>(_write_bytes);
+ _request.power_domain = std::move(power_domain);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDvfsOperatingPointRequest));
+ ::fidl::DecodedMessage<GetDvfsOperatingPointRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetDvfsOperatingPoint(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetDvfsOperatingPoint Device::SyncClient::GetDvfsOperatingPoint(::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ return ResultOf::GetDvfsOperatingPoint(::zx::unowned_channel(this->channel_), std::move(power_domain));
+}
+
+Device::ResultOf::GetDvfsOperatingPoint Device::Call::GetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ return ResultOf::GetDvfsOperatingPoint(std::move(_client_end), std::move(power_domain));
+}
+
+template <>
+Device::UnownedResultOf::GetDvfsOperatingPoint_Impl<Device::GetDvfsOperatingPointResponse>::GetDvfsOperatingPoint_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetDvfsOperatingPointRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetDvfsOperatingPointResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetDvfsOperatingPointRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetDvfsOperatingPointRequest*>(_request_buffer.data());
+ _request.power_domain = std::move(power_domain);
+ _request_buffer.set_actual(sizeof(GetDvfsOperatingPointRequest));
+ ::fidl::DecodedMessage<GetDvfsOperatingPointRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetDvfsOperatingPoint(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetDvfsOperatingPoint Device::SyncClient::GetDvfsOperatingPoint(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDvfsOperatingPoint(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(power_domain), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetDvfsOperatingPoint Device::Call::GetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDvfsOperatingPoint(std::move(_client_end), std::move(_request_buffer), std::move(power_domain), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetDvfsOperatingPointResponse> Device::InPlace::GetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetDvfsOperatingPointRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetDvfsOperatingPointRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDvfsOperatingPointResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDvfsOperatingPointRequest, GetDvfsOperatingPointResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDvfsOperatingPointResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetDvfsOperatingPoint_Impl<Device::SetDvfsOperatingPointResponse>::SetDvfsOperatingPoint_Impl(::zx::unowned_channel _client_end, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetDvfsOperatingPointRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetDvfsOperatingPointRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetDvfsOperatingPointRequest*>(_write_bytes);
+ _request.op_idx = std::move(op_idx);
+ _request.power_domain = std::move(power_domain);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetDvfsOperatingPointRequest));
+ ::fidl::DecodedMessage<SetDvfsOperatingPointRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetDvfsOperatingPoint(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetDvfsOperatingPoint Device::SyncClient::SetDvfsOperatingPoint(uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ return ResultOf::SetDvfsOperatingPoint(::zx::unowned_channel(this->channel_), std::move(op_idx), std::move(power_domain));
+}
+
+Device::ResultOf::SetDvfsOperatingPoint Device::Call::SetDvfsOperatingPoint(::zx::unowned_channel _client_end, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain) {
+ return ResultOf::SetDvfsOperatingPoint(std::move(_client_end), std::move(op_idx), std::move(power_domain));
+}
+
+template <>
+Device::UnownedResultOf::SetDvfsOperatingPoint_Impl<Device::SetDvfsOperatingPointResponse>::SetDvfsOperatingPoint_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetDvfsOperatingPointRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetDvfsOperatingPointResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetDvfsOperatingPointRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetDvfsOperatingPointRequest*>(_request_buffer.data());
+ _request.op_idx = std::move(op_idx);
+ _request.power_domain = std::move(power_domain);
+ _request_buffer.set_actual(sizeof(SetDvfsOperatingPointRequest));
+ ::fidl::DecodedMessage<SetDvfsOperatingPointRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetDvfsOperatingPoint(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetDvfsOperatingPoint Device::SyncClient::SetDvfsOperatingPoint(::fidl::BytePart _request_buffer, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetDvfsOperatingPoint(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(op_idx), std::move(power_domain), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetDvfsOperatingPoint Device::Call::SetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetDvfsOperatingPoint(std::move(_client_end), std::move(_request_buffer), std::move(op_idx), std::move(power_domain), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetDvfsOperatingPointResponse> Device::InPlace::SetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDvfsOperatingPointRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetDvfsOperatingPointRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetDvfsOperatingPointResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetDvfsOperatingPointRequest, SetDvfsOperatingPointResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetDvfsOperatingPointResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetFanLevel_Impl<Device::GetFanLevelResponse>::GetFanLevel_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFanLevelRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFanLevelRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFanLevelRequest));
+ ::fidl::DecodedMessage<GetFanLevelRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetFanLevel(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetFanLevel Device::SyncClient::GetFanLevel() {
+ return ResultOf::GetFanLevel(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetFanLevel Device::Call::GetFanLevel(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFanLevel(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetFanLevel_Impl<Device::GetFanLevelResponse>::GetFanLevel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFanLevelRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFanLevelRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFanLevelRequest));
+ ::fidl::DecodedMessage<GetFanLevelRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetFanLevel(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetFanLevel Device::SyncClient::GetFanLevel(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFanLevel(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetFanLevel Device::Call::GetFanLevel(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFanLevel(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetFanLevelResponse> Device::InPlace::GetFanLevel(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFanLevelRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFanLevelRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetFanLevelRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetFanLevelResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFanLevelRequest, GetFanLevelResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetFanLevelResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetFanLevel_Impl<Device::SetFanLevelResponse>::SetFanLevel_Impl(::zx::unowned_channel _client_end, uint32_t fan_level) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetFanLevelRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetFanLevelRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetFanLevelRequest*>(_write_bytes);
+ _request.fan_level = std::move(fan_level);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetFanLevelRequest));
+ ::fidl::DecodedMessage<SetFanLevelRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetFanLevel(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetFanLevel Device::SyncClient::SetFanLevel(uint32_t fan_level) {
+ return ResultOf::SetFanLevel(::zx::unowned_channel(this->channel_), std::move(fan_level));
+}
+
+Device::ResultOf::SetFanLevel Device::Call::SetFanLevel(::zx::unowned_channel _client_end, uint32_t fan_level) {
+ return ResultOf::SetFanLevel(std::move(_client_end), std::move(fan_level));
+}
+
+template <>
+Device::UnownedResultOf::SetFanLevel_Impl<Device::SetFanLevelResponse>::SetFanLevel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t fan_level, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetFanLevelRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetFanLevelResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetFanLevelRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetFanLevelRequest*>(_request_buffer.data());
+ _request.fan_level = std::move(fan_level);
+ _request_buffer.set_actual(sizeof(SetFanLevelRequest));
+ ::fidl::DecodedMessage<SetFanLevelRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetFanLevel(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetFanLevel Device::SyncClient::SetFanLevel(::fidl::BytePart _request_buffer, uint32_t fan_level, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetFanLevel(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(fan_level), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetFanLevel Device::Call::SetFanLevel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t fan_level, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetFanLevel(std::move(_client_end), std::move(_request_buffer), std::move(fan_level), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetFanLevelResponse> Device::InPlace::SetFanLevel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetFanLevelRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetFanLevelRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetFanLevelResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetFanLevelRequest, SetFanLevelResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetFanLevelResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetInfo_Ordinal:
+ case kDevice_GetInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInfo(
+ Interface::GetInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetDeviceInfo_Ordinal:
+ case kDevice_GetDeviceInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDeviceInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDeviceInfo(
+ Interface::GetDeviceInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetDvfsInfo_Ordinal:
+ case kDevice_GetDvfsInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDvfsInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetDvfsInfo(std::move(message->power_domain),
+ Interface::GetDvfsInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetTemperatureCelsius_Ordinal:
+ case kDevice_GetTemperatureCelsius_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTemperatureCelsiusRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetTemperatureCelsius(
+ Interface::GetTemperatureCelsiusCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetStateChangeEvent_Ordinal:
+ case kDevice_GetStateChangeEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStateChangeEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetStateChangeEvent(
+ Interface::GetStateChangeEventCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetStateChangePort_Ordinal:
+ case kDevice_GetStateChangePort_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStateChangePortRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetStateChangePort(
+ Interface::GetStateChangePortCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetTripCelsius_Ordinal:
+ case kDevice_SetTripCelsius_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetTripCelsiusRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetTripCelsius(std::move(message->id), std::move(message->temp),
+ Interface::SetTripCelsiusCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetDvfsOperatingPoint_Ordinal:
+ case kDevice_GetDvfsOperatingPoint_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDvfsOperatingPointRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetDvfsOperatingPoint(std::move(message->power_domain),
+ Interface::GetDvfsOperatingPointCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetDvfsOperatingPoint_Ordinal:
+ case kDevice_SetDvfsOperatingPoint_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetDvfsOperatingPointRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetDvfsOperatingPoint(std::move(message->op_idx), std::move(message->power_domain),
+ Interface::SetDvfsOperatingPointCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetFanLevel_Ordinal:
+ case kDevice_GetFanLevel_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFanLevelRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFanLevel(
+ Interface::GetFanLevelCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetFanLevel_Ordinal:
+ case kDevice_SetFanLevel_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetFanLevelRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetFanLevel(std::move(message->fan_level),
+ Interface::SetFanLevelCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::thermal::ThermalInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::thermal::ThermalInfo* info) {
+ if (_buffer.capacity() < GetInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetInfoResponse(
+ ::fidl::DecodedMessage<GetInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInfoResponse::PrimarySize,
+ GetInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInfoResponse> params) {
+ Device::SetTransactionHeaderFor::GetInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetDeviceInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetDeviceInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetDeviceInfoResponse(
+ ::fidl::DecodedMessage<GetDeviceInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceInfoResponse::PrimarySize,
+ GetDeviceInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetDeviceInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo* info) {
+ if (_buffer.capacity() < GetDeviceInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDeviceInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetDeviceInfoResponse(
+ ::fidl::DecodedMessage<GetDeviceInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceInfoResponse::PrimarySize,
+ GetDeviceInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetDeviceInfoCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceInfoResponse> params) {
+ Device::SetTransactionHeaderFor::GetDeviceInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetDvfsInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::hardware::thermal::OperatingPoint* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDvfsInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetDvfsInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetDvfsInfoResponse(
+ ::fidl::DecodedMessage<GetDvfsInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDvfsInfoResponse::PrimarySize,
+ GetDvfsInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetDvfsInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::thermal::OperatingPoint* info) {
+ if (_buffer.capacity() < GetDvfsInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDvfsInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetDvfsInfoResponse(
+ ::fidl::DecodedMessage<GetDvfsInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDvfsInfoResponse::PrimarySize,
+ GetDvfsInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetDvfsInfoCompleterBase::Reply(::fidl::DecodedMessage<GetDvfsInfoResponse> params) {
+ Device::SetTransactionHeaderFor::GetDvfsInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetTemperatureCelsiusCompleterBase::Reply(int32_t status, float temp) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTemperatureCelsiusResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetTemperatureCelsiusResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetTemperatureCelsiusResponse(
+ ::fidl::DecodedMessage<GetTemperatureCelsiusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTemperatureCelsiusResponse::PrimarySize,
+ GetTemperatureCelsiusResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.temp = std::move(temp);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTemperatureCelsiusResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetTemperatureCelsiusResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetTemperatureCelsiusCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, float temp) {
+ if (_buffer.capacity() < GetTemperatureCelsiusResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetTemperatureCelsiusResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetTemperatureCelsiusResponse(
+ ::fidl::DecodedMessage<GetTemperatureCelsiusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTemperatureCelsiusResponse::PrimarySize,
+ GetTemperatureCelsiusResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.temp = std::move(temp);
+ _buffer.set_actual(sizeof(GetTemperatureCelsiusResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetTemperatureCelsiusResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetTemperatureCelsiusCompleterBase::Reply(::fidl::DecodedMessage<GetTemperatureCelsiusResponse> params) {
+ Device::SetTransactionHeaderFor::GetTemperatureCelsiusResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetStateChangeEventCompleterBase::Reply(int32_t status, ::zx::event handle) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateChangeEventResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetStateChangeEventResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetStateChangeEventResponse(
+ ::fidl::DecodedMessage<GetStateChangeEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateChangeEventResponse::PrimarySize,
+ GetStateChangeEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.handle = std::move(handle);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStateChangeEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetStateChangeEventResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetStateChangeEventCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event handle) {
+ if (_buffer.capacity() < GetStateChangeEventResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetStateChangeEventResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetStateChangeEventResponse(
+ ::fidl::DecodedMessage<GetStateChangeEventResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateChangeEventResponse::PrimarySize,
+ GetStateChangeEventResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.handle = std::move(handle);
+ _buffer.set_actual(sizeof(GetStateChangeEventResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetStateChangeEventResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetStateChangeEventCompleterBase::Reply(::fidl::DecodedMessage<GetStateChangeEventResponse> params) {
+ Device::SetTransactionHeaderFor::GetStateChangeEventResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetStateChangePortCompleterBase::Reply(int32_t status, ::zx::port handle) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStateChangePortResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetStateChangePortResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetStateChangePortResponse(
+ ::fidl::DecodedMessage<GetStateChangePortResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateChangePortResponse::PrimarySize,
+ GetStateChangePortResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.handle = std::move(handle);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStateChangePortResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetStateChangePortResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetStateChangePortCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::port handle) {
+ if (_buffer.capacity() < GetStateChangePortResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetStateChangePortResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetStateChangePortResponse(
+ ::fidl::DecodedMessage<GetStateChangePortResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStateChangePortResponse::PrimarySize,
+ GetStateChangePortResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.handle = std::move(handle);
+ _buffer.set_actual(sizeof(GetStateChangePortResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetStateChangePortResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetStateChangePortCompleterBase::Reply(::fidl::DecodedMessage<GetStateChangePortResponse> params) {
+ Device::SetTransactionHeaderFor::GetStateChangePortResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetTripCelsiusCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTripCelsiusResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetTripCelsiusResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetTripCelsiusResponse(
+ ::fidl::DecodedMessage<SetTripCelsiusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetTripCelsiusResponse::PrimarySize,
+ SetTripCelsiusResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTripCelsiusResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetTripCelsiusResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetTripCelsiusCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetTripCelsiusResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetTripCelsiusResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetTripCelsiusResponse(
+ ::fidl::DecodedMessage<SetTripCelsiusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetTripCelsiusResponse::PrimarySize,
+ SetTripCelsiusResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetTripCelsiusResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetTripCelsiusResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetTripCelsiusCompleterBase::Reply(::fidl::DecodedMessage<SetTripCelsiusResponse> params) {
+ Device::SetTransactionHeaderFor::SetTripCelsiusResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetDvfsOperatingPointCompleterBase::Reply(int32_t status, uint16_t op_idx) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDvfsOperatingPointResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetDvfsOperatingPointResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetDvfsOperatingPointResponse(
+ ::fidl::DecodedMessage<GetDvfsOperatingPointResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDvfsOperatingPointResponse::PrimarySize,
+ GetDvfsOperatingPointResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.op_idx = std::move(op_idx);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDvfsOperatingPointResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDvfsOperatingPointResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetDvfsOperatingPointCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint16_t op_idx) {
+ if (_buffer.capacity() < GetDvfsOperatingPointResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetDvfsOperatingPointResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetDvfsOperatingPointResponse(
+ ::fidl::DecodedMessage<GetDvfsOperatingPointResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDvfsOperatingPointResponse::PrimarySize,
+ GetDvfsOperatingPointResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.op_idx = std::move(op_idx);
+ _buffer.set_actual(sizeof(GetDvfsOperatingPointResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDvfsOperatingPointResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetDvfsOperatingPointCompleterBase::Reply(::fidl::DecodedMessage<GetDvfsOperatingPointResponse> params) {
+ Device::SetTransactionHeaderFor::GetDvfsOperatingPointResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetDvfsOperatingPointCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetDvfsOperatingPointResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetDvfsOperatingPointResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetDvfsOperatingPointResponse(
+ ::fidl::DecodedMessage<SetDvfsOperatingPointResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetDvfsOperatingPointResponse::PrimarySize,
+ SetDvfsOperatingPointResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetDvfsOperatingPointResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetDvfsOperatingPointResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetDvfsOperatingPointCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetDvfsOperatingPointResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetDvfsOperatingPointResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetDvfsOperatingPointResponse(
+ ::fidl::DecodedMessage<SetDvfsOperatingPointResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetDvfsOperatingPointResponse::PrimarySize,
+ SetDvfsOperatingPointResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetDvfsOperatingPointResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetDvfsOperatingPointResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetDvfsOperatingPointCompleterBase::Reply(::fidl::DecodedMessage<SetDvfsOperatingPointResponse> params) {
+ Device::SetTransactionHeaderFor::SetDvfsOperatingPointResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetFanLevelCompleterBase::Reply(int32_t status, uint32_t fan_level) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFanLevelResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetFanLevelResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetFanLevelResponse(
+ ::fidl::DecodedMessage<GetFanLevelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFanLevelResponse::PrimarySize,
+ GetFanLevelResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.fan_level = std::move(fan_level);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFanLevelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFanLevelResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetFanLevelCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint32_t fan_level) {
+ if (_buffer.capacity() < GetFanLevelResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetFanLevelResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetFanLevelResponse(
+ ::fidl::DecodedMessage<GetFanLevelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFanLevelResponse::PrimarySize,
+ GetFanLevelResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.fan_level = std::move(fan_level);
+ _buffer.set_actual(sizeof(GetFanLevelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFanLevelResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetFanLevelCompleterBase::Reply(::fidl::DecodedMessage<GetFanLevelResponse> params) {
+ Device::SetTransactionHeaderFor::GetFanLevelResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetFanLevelCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetFanLevelResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetFanLevelResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetFanLevelResponse(
+ ::fidl::DecodedMessage<SetFanLevelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetFanLevelResponse::PrimarySize,
+ SetFanLevelResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetFanLevelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetFanLevelResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetFanLevelCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetFanLevelResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetFanLevelResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetFanLevelResponse(
+ ::fidl::DecodedMessage<SetFanLevelResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetFanLevelResponse::PrimarySize,
+ SetFanLevelResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetFanLevelResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetFanLevelResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetFanLevelCompleterBase::Reply(::fidl::DecodedMessage<SetFanLevelResponse> params) {
+ Device::SetTransactionHeaderFor::SetFanLevelResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetInfoRequest(const ::fidl::DecodedMessage<Device::GetInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetInfoResponse(const ::fidl::DecodedMessage<Device::GetInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetDeviceInfoRequest(const ::fidl::DecodedMessage<Device::GetDeviceInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetDeviceInfoResponse(const ::fidl::DecodedMessage<Device::GetDeviceInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetDvfsInfoRequest(const ::fidl::DecodedMessage<Device::GetDvfsInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDvfsInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetDvfsInfoResponse(const ::fidl::DecodedMessage<Device::GetDvfsInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDvfsInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetTemperatureCelsiusRequest(const ::fidl::DecodedMessage<Device::GetTemperatureCelsiusRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetTemperatureCelsius_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetTemperatureCelsiusResponse(const ::fidl::DecodedMessage<Device::GetTemperatureCelsiusResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetTemperatureCelsius_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetStateChangeEventRequest(const ::fidl::DecodedMessage<Device::GetStateChangeEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStateChangeEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetStateChangeEventResponse(const ::fidl::DecodedMessage<Device::GetStateChangeEventResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStateChangeEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetStateChangePortRequest(const ::fidl::DecodedMessage<Device::GetStateChangePortRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStateChangePort_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetStateChangePortResponse(const ::fidl::DecodedMessage<Device::GetStateChangePortResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStateChangePort_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetTripCelsiusRequest(const ::fidl::DecodedMessage<Device::SetTripCelsiusRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetTripCelsius_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetTripCelsiusResponse(const ::fidl::DecodedMessage<Device::SetTripCelsiusResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetTripCelsius_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetDvfsOperatingPointRequest(const ::fidl::DecodedMessage<Device::GetDvfsOperatingPointRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDvfsOperatingPoint_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetDvfsOperatingPointResponse(const ::fidl::DecodedMessage<Device::GetDvfsOperatingPointResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDvfsOperatingPoint_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetDvfsOperatingPointRequest(const ::fidl::DecodedMessage<Device::SetDvfsOperatingPointRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetDvfsOperatingPoint_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetDvfsOperatingPointResponse(const ::fidl::DecodedMessage<Device::SetDvfsOperatingPointResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetDvfsOperatingPoint_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetFanLevelRequest(const ::fidl::DecodedMessage<Device::GetFanLevelRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetFanLevel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetFanLevelResponse(const ::fidl::DecodedMessage<Device::GetFanLevelResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetFanLevel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetFanLevelRequest(const ::fidl::DecodedMessage<Device::SetFanLevelRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetFanLevel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetFanLevelResponse(const ::fidl::DecodedMessage<Device::SetFanLevelResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetFanLevel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace thermal
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-thermal/gen/llcpp/include/fuchsia/hardware/thermal/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-thermal/gen/llcpp/include/fuchsia/hardware/thermal/llcpp/fidl.h
new file mode 100644
index 0000000..6a00646
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-thermal/gen/llcpp/include/fuchsia/hardware/thermal/llcpp/fidl.h
@@ -0,0 +1,1548 @@
+// 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/event.h>
+#include <lib/zx/port.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace thermal {
+
+struct ThermalTemperatureInfo;
+struct ThermalInfo;
+enum class PowerDomain : uint32_t {
+ BIG_CLUSTER_POWER_DOMAIN = 0u,
+ LITTLE_CLUSTER_POWER_DOMAIN = 1u,
+};
+
+
+class Device;
+struct OperatingPointEntry;
+struct OperatingPoint;
+struct ThermalDeviceInfo;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_ThermalTemperatureInfoTable;
+
+// Temperature units are degrees Celsius.
+struct ThermalTemperatureInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_ThermalTemperatureInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 20;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The temperature must rise to up_temp to get to this trip point.
+ float up_temp_celsius = {};
+
+ // The temperature must fall to down_temp to get to this trip point.
+ float down_temp_celsius = {};
+
+ // The fan level for this trip point.
+ uint32_t fan_level = {};
+
+ // The operating point index of the big cluster.
+ uint16_t big_cluster_dvfs_opp = {};
+
+ // The operating point index of the little cluster.
+ uint16_t little_cluster_dvfs_opp = {};
+
+ // The GPU clock source index.
+ uint32_t gpu_clk_freq_source = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_ThermalInfoTable;
+
+// Temperature units are degrees Celsius.
+struct ThermalInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_ThermalInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // State is a bitmask of `THERMAL_STATE_`* values.
+ uint32_t state = {};
+
+ // The sensor temperature at which the system should activate passive cooling policy.
+ float passive_temp_celsius = {};
+
+ // The sensor temperature at which the system should perform critical shutdown.
+ float critical_temp_celsius = {};
+
+ // The number of trip points supported.
+ uint32_t max_trip_count = {};
+
+ // The currently active trip point.
+ ::fidl::Array<float, 16> active_trip = {};
+};
+
+constexpr uint32_t THERMAL_STATE_TRIP_VIOLATION = 1u;
+
+// Bitmask values for ThermalInfo.state.
+constexpr uint32_t THERMAL_STATE_NORMAL = 0u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDeviceInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDeviceInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDvfsInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDvfsInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetTemperatureCelsiusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetTemperatureCelsiusResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetStateChangeEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetStateChangeEventResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetStateChangePortRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetStateChangePortResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetTripCelsiusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetTripCelsiusResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDvfsOperatingPointRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetDvfsOperatingPointResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetDvfsOperatingPointRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetDvfsOperatingPointResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetFanLevelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceGetFanLevelResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetFanLevelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_DeviceSetFanLevelResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::hardware::thermal::ThermalInfo* info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 80;
+ 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 GetDeviceInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo* info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetDeviceInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 608;
+ 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 GetDeviceInfoRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDvfsInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::hardware::thermal::OperatingPoint* info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetDvfsInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 136;
+ 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 GetDvfsInfoRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetDvfsInfoRequestTable;
+ 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 = GetDvfsInfoResponse;
+ };
+
+ struct GetTemperatureCelsiusResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ float temp;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetTemperatureCelsiusResponseTable;
+ 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 GetTemperatureCelsiusRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetStateChangeEventResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::event handle;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetStateChangeEventResponseTable;
+ 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 GetStateChangeEventRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetStateChangePortResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::port handle;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetStateChangePortResponseTable;
+ 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 GetStateChangePortRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetTripCelsiusResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceSetTripCelsiusResponseTable;
+ 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 SetTripCelsiusRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t id;
+ float temp;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceSetTripCelsiusRequestTable;
+ 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 = SetTripCelsiusResponse;
+ };
+
+ struct GetDvfsOperatingPointResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint16_t op_idx;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetDvfsOperatingPointResponseTable;
+ 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 GetDvfsOperatingPointRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetDvfsOperatingPointRequestTable;
+ 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 = GetDvfsOperatingPointResponse;
+ };
+
+ struct SetDvfsOperatingPointResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceSetDvfsOperatingPointResponseTable;
+ 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 SetDvfsOperatingPointRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint16_t op_idx;
+ ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceSetDvfsOperatingPointRequestTable;
+ 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 = SetDvfsOperatingPointResponse;
+ };
+
+ struct GetFanLevelResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint32_t fan_level;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceGetFanLevelResponseTable;
+ 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 GetFanLevelRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetFanLevelResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceSetFanLevelResponseTable;
+ 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 SetFanLevelRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t fan_level;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_DeviceSetFanLevelRequestTable;
+ 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 = SetFanLevelResponse;
+ };
+
+
+ // 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 GetDeviceInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceInfo_Impl(::zx::unowned_channel _client_end);
+ ~GetDeviceInfo_Impl() = default;
+ GetDeviceInfo_Impl(GetDeviceInfo_Impl&& other) = default;
+ GetDeviceInfo_Impl& operator=(GetDeviceInfo_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 GetDvfsInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDvfsInfo_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+ ~GetDvfsInfo_Impl() = default;
+ GetDvfsInfo_Impl(GetDvfsInfo_Impl&& other) = default;
+ GetDvfsInfo_Impl& operator=(GetDvfsInfo_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 GetTemperatureCelsius_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetTemperatureCelsius_Impl(::zx::unowned_channel _client_end);
+ ~GetTemperatureCelsius_Impl() = default;
+ GetTemperatureCelsius_Impl(GetTemperatureCelsius_Impl&& other) = default;
+ GetTemperatureCelsius_Impl& operator=(GetTemperatureCelsius_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 GetStateChangeEvent_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetStateChangeEvent_Impl(::zx::unowned_channel _client_end);
+ ~GetStateChangeEvent_Impl() = default;
+ GetStateChangeEvent_Impl(GetStateChangeEvent_Impl&& other) = default;
+ GetStateChangeEvent_Impl& operator=(GetStateChangeEvent_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 GetStateChangePort_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetStateChangePort_Impl(::zx::unowned_channel _client_end);
+ ~GetStateChangePort_Impl() = default;
+ GetStateChangePort_Impl(GetStateChangePort_Impl&& other) = default;
+ GetStateChangePort_Impl& operator=(GetStateChangePort_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 SetTripCelsius_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetTripCelsius_Impl(::zx::unowned_channel _client_end, uint32_t id, float temp);
+ ~SetTripCelsius_Impl() = default;
+ SetTripCelsius_Impl(SetTripCelsius_Impl&& other) = default;
+ SetTripCelsius_Impl& operator=(SetTripCelsius_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 GetDvfsOperatingPoint_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDvfsOperatingPoint_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+ ~GetDvfsOperatingPoint_Impl() = default;
+ GetDvfsOperatingPoint_Impl(GetDvfsOperatingPoint_Impl&& other) = default;
+ GetDvfsOperatingPoint_Impl& operator=(GetDvfsOperatingPoint_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 SetDvfsOperatingPoint_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetDvfsOperatingPoint_Impl(::zx::unowned_channel _client_end, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+ ~SetDvfsOperatingPoint_Impl() = default;
+ SetDvfsOperatingPoint_Impl(SetDvfsOperatingPoint_Impl&& other) = default;
+ SetDvfsOperatingPoint_Impl& operator=(SetDvfsOperatingPoint_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 GetFanLevel_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetFanLevel_Impl(::zx::unowned_channel _client_end);
+ ~GetFanLevel_Impl() = default;
+ GetFanLevel_Impl(GetFanLevel_Impl&& other) = default;
+ GetFanLevel_Impl& operator=(GetFanLevel_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 SetFanLevel_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetFanLevel_Impl(::zx::unowned_channel _client_end, uint32_t fan_level);
+ ~SetFanLevel_Impl() = default;
+ SetFanLevel_Impl(SetFanLevel_Impl&& other) = default;
+ SetFanLevel_Impl& operator=(SetFanLevel_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 GetDeviceInfo = GetDeviceInfo_Impl<GetDeviceInfoResponse>;
+ using GetDvfsInfo = GetDvfsInfo_Impl<GetDvfsInfoResponse>;
+ using GetTemperatureCelsius = GetTemperatureCelsius_Impl<GetTemperatureCelsiusResponse>;
+ using GetStateChangeEvent = GetStateChangeEvent_Impl<GetStateChangeEventResponse>;
+ using GetStateChangePort = GetStateChangePort_Impl<GetStateChangePortResponse>;
+ using SetTripCelsius = SetTripCelsius_Impl<SetTripCelsiusResponse>;
+ using GetDvfsOperatingPoint = GetDvfsOperatingPoint_Impl<GetDvfsOperatingPointResponse>;
+ using SetDvfsOperatingPoint = SetDvfsOperatingPoint_Impl<SetDvfsOperatingPointResponse>;
+ using GetFanLevel = GetFanLevel_Impl<GetFanLevelResponse>;
+ using SetFanLevel = SetFanLevel_Impl<SetFanLevelResponse>;
+ };
+
+ // 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 GetDeviceInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDeviceInfo_Impl() = default;
+ GetDeviceInfo_Impl(GetDeviceInfo_Impl&& other) = default;
+ GetDeviceInfo_Impl& operator=(GetDeviceInfo_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 GetDvfsInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDvfsInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+ ~GetDvfsInfo_Impl() = default;
+ GetDvfsInfo_Impl(GetDvfsInfo_Impl&& other) = default;
+ GetDvfsInfo_Impl& operator=(GetDvfsInfo_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 GetTemperatureCelsius_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetTemperatureCelsius_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetTemperatureCelsius_Impl() = default;
+ GetTemperatureCelsius_Impl(GetTemperatureCelsius_Impl&& other) = default;
+ GetTemperatureCelsius_Impl& operator=(GetTemperatureCelsius_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 GetStateChangeEvent_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetStateChangeEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetStateChangeEvent_Impl() = default;
+ GetStateChangeEvent_Impl(GetStateChangeEvent_Impl&& other) = default;
+ GetStateChangeEvent_Impl& operator=(GetStateChangeEvent_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 GetStateChangePort_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetStateChangePort_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetStateChangePort_Impl() = default;
+ GetStateChangePort_Impl(GetStateChangePort_Impl&& other) = default;
+ GetStateChangePort_Impl& operator=(GetStateChangePort_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 SetTripCelsius_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetTripCelsius_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, float temp, ::fidl::BytePart _response_buffer);
+ ~SetTripCelsius_Impl() = default;
+ SetTripCelsius_Impl(SetTripCelsius_Impl&& other) = default;
+ SetTripCelsius_Impl& operator=(SetTripCelsius_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 GetDvfsOperatingPoint_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDvfsOperatingPoint_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+ ~GetDvfsOperatingPoint_Impl() = default;
+ GetDvfsOperatingPoint_Impl(GetDvfsOperatingPoint_Impl&& other) = default;
+ GetDvfsOperatingPoint_Impl& operator=(GetDvfsOperatingPoint_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 SetDvfsOperatingPoint_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetDvfsOperatingPoint_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+ ~SetDvfsOperatingPoint_Impl() = default;
+ SetDvfsOperatingPoint_Impl(SetDvfsOperatingPoint_Impl&& other) = default;
+ SetDvfsOperatingPoint_Impl& operator=(SetDvfsOperatingPoint_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 GetFanLevel_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetFanLevel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetFanLevel_Impl() = default;
+ GetFanLevel_Impl(GetFanLevel_Impl&& other) = default;
+ GetFanLevel_Impl& operator=(GetFanLevel_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 SetFanLevel_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetFanLevel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t fan_level, ::fidl::BytePart _response_buffer);
+ ~SetFanLevel_Impl() = default;
+ SetFanLevel_Impl(SetFanLevel_Impl&& other) = default;
+ SetFanLevel_Impl& operator=(SetFanLevel_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 GetDeviceInfo = GetDeviceInfo_Impl<GetDeviceInfoResponse>;
+ using GetDvfsInfo = GetDvfsInfo_Impl<GetDvfsInfoResponse>;
+ using GetTemperatureCelsius = GetTemperatureCelsius_Impl<GetTemperatureCelsiusResponse>;
+ using GetStateChangeEvent = GetStateChangeEvent_Impl<GetStateChangeEventResponse>;
+ using GetStateChangePort = GetStateChangePort_Impl<GetStateChangePortResponse>;
+ using SetTripCelsius = SetTripCelsius_Impl<SetTripCelsiusResponse>;
+ using GetDvfsOperatingPoint = GetDvfsOperatingPoint_Impl<GetDvfsOperatingPointResponse>;
+ using SetDvfsOperatingPoint = SetDvfsOperatingPoint_Impl<SetDvfsOperatingPointResponse>;
+ using GetFanLevel = GetFanLevel_Impl<GetFanLevelResponse>;
+ using SetFanLevel = SetFanLevel_Impl<SetFanLevelResponse>;
+ };
+
+ 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_; }
+
+ // Get information about the device's current state.
+ // Allocates 128 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetInfo GetInfo();
+
+ // Get information about the device's current state.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetInfo GetInfo(::fidl::BytePart _response_buffer);
+
+ // Get information about the device's thermal capabilities and trip points.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetDeviceInfo GetDeviceInfo();
+
+ // Get information about the device's thermal capabilities and trip points.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDeviceInfo GetDeviceInfo(::fidl::BytePart _response_buffer);
+
+ // Get the device's operating points.
+ // TODO(bradenkell): Can this be removed? GetDeviceInfo() provides the same information.
+ // Allocates 192 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDvfsInfo GetDvfsInfo(::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+
+ // Get the device's operating points.
+ // TODO(bradenkell): Can this be removed? GetDeviceInfo() provides the same information.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDvfsInfo GetDvfsInfo(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+
+ // Get the current temperature in degrees Celsius.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetTemperatureCelsius GetTemperatureCelsius();
+
+ // Get the current temperature in degrees Celsius.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetTemperatureCelsius GetTemperatureCelsius(::fidl::BytePart _response_buffer);
+
+ // Get an event to get trip point notifications on. `ZX_USER_SIGNAL_`0 is changed when either
+ // trip point is reached. It is deasserted when the state is read via GetInfo.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetStateChangeEvent GetStateChangeEvent();
+
+ // Get an event to get trip point notifications on. `ZX_USER_SIGNAL_`0 is changed when either
+ // trip point is reached. It is deasserted when the state is read via GetInfo.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetStateChangeEvent GetStateChangeEvent(::fidl::BytePart _response_buffer);
+
+ // Get a port to get trip point notification packets.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetStateChangePort GetStateChangePort();
+
+ // Get a port to get trip point notification packets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetStateChangePort GetStateChangePort(::fidl::BytePart _response_buffer);
+
+ // Sets a trip point in degrees Celsius. When the sensor reaches the trip point temperature the
+ // device will notify on an event.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetTripCelsius SetTripCelsius(uint32_t id, float temp);
+
+ // Sets a trip point in degrees Celsius. When the sensor reaches the trip point temperature the
+ // device will notify on an event.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetTripCelsius SetTripCelsius(::fidl::BytePart _request_buffer, uint32_t id, float temp, ::fidl::BytePart _response_buffer);
+
+ // Get the current operating point index.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDvfsOperatingPoint GetDvfsOperatingPoint(::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+
+ // Get the current operating point index.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDvfsOperatingPoint GetDvfsOperatingPoint(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+
+ // Set the operating point index.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetDvfsOperatingPoint SetDvfsOperatingPoint(uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+
+ // Set the operating point index.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetDvfsOperatingPoint SetDvfsOperatingPoint(::fidl::BytePart _request_buffer, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+
+ // Get the current fan level.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetFanLevel GetFanLevel();
+
+ // Get the current fan level.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetFanLevel GetFanLevel(::fidl::BytePart _response_buffer);
+
+ // Set the fan level.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetFanLevel SetFanLevel(uint32_t fan_level);
+
+ // Set the fan level.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetFanLevel SetFanLevel(::fidl::BytePart _request_buffer, uint32_t fan_level, ::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:
+
+ // Get information about the device's current state.
+ // Allocates 128 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetInfo GetInfo(::zx::unowned_channel _client_end);
+
+ // Get information about the device's current state.
+ // 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);
+
+ // Get information about the device's thermal capabilities and trip points.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetDeviceInfo GetDeviceInfo(::zx::unowned_channel _client_end);
+
+ // Get information about the device's thermal capabilities and trip points.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDeviceInfo GetDeviceInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get the device's operating points.
+ // TODO(bradenkell): Can this be removed? GetDeviceInfo() provides the same information.
+ // Allocates 192 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDvfsInfo GetDvfsInfo(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+
+ // Get the device's operating points.
+ // TODO(bradenkell): Can this be removed? GetDeviceInfo() provides the same information.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDvfsInfo GetDvfsInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+
+ // Get the current temperature in degrees Celsius.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetTemperatureCelsius GetTemperatureCelsius(::zx::unowned_channel _client_end);
+
+ // Get the current temperature in degrees Celsius.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetTemperatureCelsius GetTemperatureCelsius(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get an event to get trip point notifications on. `ZX_USER_SIGNAL_`0 is changed when either
+ // trip point is reached. It is deasserted when the state is read via GetInfo.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetStateChangeEvent GetStateChangeEvent(::zx::unowned_channel _client_end);
+
+ // Get an event to get trip point notifications on. `ZX_USER_SIGNAL_`0 is changed when either
+ // trip point is reached. It is deasserted when the state is read via GetInfo.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetStateChangeEvent GetStateChangeEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Get a port to get trip point notification packets.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetStateChangePort GetStateChangePort(::zx::unowned_channel _client_end);
+
+ // Get a port to get trip point notification packets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetStateChangePort GetStateChangePort(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets a trip point in degrees Celsius. When the sensor reaches the trip point temperature the
+ // device will notify on an event.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetTripCelsius SetTripCelsius(::zx::unowned_channel _client_end, uint32_t id, float temp);
+
+ // Sets a trip point in degrees Celsius. When the sensor reaches the trip point temperature the
+ // device will notify on an event.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetTripCelsius SetTripCelsius(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t id, float temp, ::fidl::BytePart _response_buffer);
+
+ // Get the current operating point index.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDvfsOperatingPoint GetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+
+ // Get the current operating point index.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDvfsOperatingPoint GetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+
+ // Set the operating point index.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetDvfsOperatingPoint SetDvfsOperatingPoint(::zx::unowned_channel _client_end, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain);
+
+ // Set the operating point index.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetDvfsOperatingPoint SetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, ::fidl::BytePart _response_buffer);
+
+ // Get the current fan level.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetFanLevel GetFanLevel(::zx::unowned_channel _client_end);
+
+ // Get the current fan level.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetFanLevel GetFanLevel(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Set the fan level.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetFanLevel SetFanLevel(::zx::unowned_channel _client_end, uint32_t fan_level);
+
+ // Set the fan level.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetFanLevel SetFanLevel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t fan_level, ::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:
+
+ // Get information about the device's current state.
+ static ::fidl::DecodeResult<GetInfoResponse> GetInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get information about the device's thermal capabilities and trip points.
+ static ::fidl::DecodeResult<GetDeviceInfoResponse> GetDeviceInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get the device's operating points.
+ // TODO(bradenkell): Can this be removed? GetDeviceInfo() provides the same information.
+ static ::fidl::DecodeResult<GetDvfsInfoResponse> GetDvfsInfo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetDvfsInfoRequest> params, ::fidl::BytePart response_buffer);
+
+ // Get the current temperature in degrees Celsius.
+ static ::fidl::DecodeResult<GetTemperatureCelsiusResponse> GetTemperatureCelsius(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get an event to get trip point notifications on. `ZX_USER_SIGNAL_`0 is changed when either
+ // trip point is reached. It is deasserted when the state is read via GetInfo.
+ static ::fidl::DecodeResult<GetStateChangeEventResponse> GetStateChangeEvent(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Get a port to get trip point notification packets.
+ static ::fidl::DecodeResult<GetStateChangePortResponse> GetStateChangePort(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets a trip point in degrees Celsius. When the sensor reaches the trip point temperature the
+ // device will notify on an event.
+ static ::fidl::DecodeResult<SetTripCelsiusResponse> SetTripCelsius(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTripCelsiusRequest> params, ::fidl::BytePart response_buffer);
+
+ // Get the current operating point index.
+ static ::fidl::DecodeResult<GetDvfsOperatingPointResponse> GetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetDvfsOperatingPointRequest> params, ::fidl::BytePart response_buffer);
+
+ // Set the operating point index.
+ static ::fidl::DecodeResult<SetDvfsOperatingPointResponse> SetDvfsOperatingPoint(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetDvfsOperatingPointRequest> params, ::fidl::BytePart response_buffer);
+
+ // Get the current fan level.
+ static ::fidl::DecodeResult<GetFanLevelResponse> GetFanLevel(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Set the fan level.
+ static ::fidl::DecodeResult<SetFanLevelResponse> SetFanLevel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetFanLevelRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetInfoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::hardware::thermal::ThermalInfo* info);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::thermal::ThermalInfo* 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 GetDeviceInfoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo* info);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo* info);
+ void Reply(::fidl::DecodedMessage<GetDeviceInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDeviceInfoCompleter = ::fidl::Completer<GetDeviceInfoCompleterBase>;
+
+ virtual void GetDeviceInfo(GetDeviceInfoCompleter::Sync _completer) = 0;
+
+ class GetDvfsInfoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::hardware::thermal::OperatingPoint* info);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::hardware::thermal::OperatingPoint* info);
+ void Reply(::fidl::DecodedMessage<GetDvfsInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDvfsInfoCompleter = ::fidl::Completer<GetDvfsInfoCompleterBase>;
+
+ virtual void GetDvfsInfo(::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, GetDvfsInfoCompleter::Sync _completer) = 0;
+
+ class GetTemperatureCelsiusCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, float temp);
+ void Reply(::fidl::BytePart _buffer, int32_t status, float temp);
+ void Reply(::fidl::DecodedMessage<GetTemperatureCelsiusResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTemperatureCelsiusCompleter = ::fidl::Completer<GetTemperatureCelsiusCompleterBase>;
+
+ virtual void GetTemperatureCelsius(GetTemperatureCelsiusCompleter::Sync _completer) = 0;
+
+ class GetStateChangeEventCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::event handle);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::event handle);
+ void Reply(::fidl::DecodedMessage<GetStateChangeEventResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetStateChangeEventCompleter = ::fidl::Completer<GetStateChangeEventCompleterBase>;
+
+ virtual void GetStateChangeEvent(GetStateChangeEventCompleter::Sync _completer) = 0;
+
+ class GetStateChangePortCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::port handle);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::port handle);
+ void Reply(::fidl::DecodedMessage<GetStateChangePortResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetStateChangePortCompleter = ::fidl::Completer<GetStateChangePortCompleterBase>;
+
+ virtual void GetStateChangePort(GetStateChangePortCompleter::Sync _completer) = 0;
+
+ class SetTripCelsiusCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetTripCelsiusResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetTripCelsiusCompleter = ::fidl::Completer<SetTripCelsiusCompleterBase>;
+
+ virtual void SetTripCelsius(uint32_t id, float temp, SetTripCelsiusCompleter::Sync _completer) = 0;
+
+ class GetDvfsOperatingPointCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint16_t op_idx);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint16_t op_idx);
+ void Reply(::fidl::DecodedMessage<GetDvfsOperatingPointResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDvfsOperatingPointCompleter = ::fidl::Completer<GetDvfsOperatingPointCompleterBase>;
+
+ virtual void GetDvfsOperatingPoint(::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, GetDvfsOperatingPointCompleter::Sync _completer) = 0;
+
+ class SetDvfsOperatingPointCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetDvfsOperatingPointResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetDvfsOperatingPointCompleter = ::fidl::Completer<SetDvfsOperatingPointCompleterBase>;
+
+ virtual void SetDvfsOperatingPoint(uint16_t op_idx, ::llcpp::fuchsia::hardware::thermal::PowerDomain power_domain, SetDvfsOperatingPointCompleter::Sync _completer) = 0;
+
+ class GetFanLevelCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint32_t fan_level);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint32_t fan_level);
+ void Reply(::fidl::DecodedMessage<GetFanLevelResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetFanLevelCompleter = ::fidl::Completer<GetFanLevelCompleterBase>;
+
+ virtual void GetFanLevel(GetFanLevelCompleter::Sync _completer) = 0;
+
+ class SetFanLevelCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetFanLevelResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetFanLevelCompleter = ::fidl::Completer<SetFanLevelCompleterBase>;
+
+ virtual void SetFanLevel(uint32_t fan_level, SetFanLevelCompleter::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<Device::GetInfoRequest>& _msg);
+ static void GetInfoResponse(const ::fidl::DecodedMessage<Device::GetInfoResponse>& _msg);
+ static void GetDeviceInfoRequest(const ::fidl::DecodedMessage<Device::GetDeviceInfoRequest>& _msg);
+ static void GetDeviceInfoResponse(const ::fidl::DecodedMessage<Device::GetDeviceInfoResponse>& _msg);
+ static void GetDvfsInfoRequest(const ::fidl::DecodedMessage<Device::GetDvfsInfoRequest>& _msg);
+ static void GetDvfsInfoResponse(const ::fidl::DecodedMessage<Device::GetDvfsInfoResponse>& _msg);
+ static void GetTemperatureCelsiusRequest(const ::fidl::DecodedMessage<Device::GetTemperatureCelsiusRequest>& _msg);
+ static void GetTemperatureCelsiusResponse(const ::fidl::DecodedMessage<Device::GetTemperatureCelsiusResponse>& _msg);
+ static void GetStateChangeEventRequest(const ::fidl::DecodedMessage<Device::GetStateChangeEventRequest>& _msg);
+ static void GetStateChangeEventResponse(const ::fidl::DecodedMessage<Device::GetStateChangeEventResponse>& _msg);
+ static void GetStateChangePortRequest(const ::fidl::DecodedMessage<Device::GetStateChangePortRequest>& _msg);
+ static void GetStateChangePortResponse(const ::fidl::DecodedMessage<Device::GetStateChangePortResponse>& _msg);
+ static void SetTripCelsiusRequest(const ::fidl::DecodedMessage<Device::SetTripCelsiusRequest>& _msg);
+ static void SetTripCelsiusResponse(const ::fidl::DecodedMessage<Device::SetTripCelsiusResponse>& _msg);
+ static void GetDvfsOperatingPointRequest(const ::fidl::DecodedMessage<Device::GetDvfsOperatingPointRequest>& _msg);
+ static void GetDvfsOperatingPointResponse(const ::fidl::DecodedMessage<Device::GetDvfsOperatingPointResponse>& _msg);
+ static void SetDvfsOperatingPointRequest(const ::fidl::DecodedMessage<Device::SetDvfsOperatingPointRequest>& _msg);
+ static void SetDvfsOperatingPointResponse(const ::fidl::DecodedMessage<Device::SetDvfsOperatingPointResponse>& _msg);
+ static void GetFanLevelRequest(const ::fidl::DecodedMessage<Device::GetFanLevelRequest>& _msg);
+ static void GetFanLevelResponse(const ::fidl::DecodedMessage<Device::GetFanLevelResponse>& _msg);
+ static void SetFanLevelRequest(const ::fidl::DecodedMessage<Device::SetFanLevelRequest>& _msg);
+ static void SetFanLevelResponse(const ::fidl::DecodedMessage<Device::SetFanLevelResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_OperatingPointEntryTable;
+
+// scpi_opp_entry_t is typedef'd to this.
+struct OperatingPointEntry {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_OperatingPointEntryTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The operating point frequency in Hz.
+ uint32_t freq_hz = {};
+
+ // The operating point voltage in microvolts.
+ uint32_t volt_uv = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_OperatingPointTable;
+
+// scpi_opp_t is typedef'd to this.
+struct OperatingPoint {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_OperatingPointTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 136;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The device's operating points.
+ ::fidl::Array<::llcpp::fuchsia::hardware::thermal::OperatingPointEntry, 16> opp = {};
+
+ // In microseconds.
+ uint32_t latency = {};
+
+ // The number of operating points in opp.
+ uint32_t count = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_thermal_ThermalDeviceInfoTable;
+
+struct ThermalDeviceInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_thermal_ThermalDeviceInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 608;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Active cooling support.
+ bool active_cooling = {};
+
+ // Passive cooling support.
+ bool passive_cooling = {};
+
+ // GPU throttling support.
+ bool gpu_throttling = {};
+
+ // Number of trip points.
+ uint32_t num_trip_points = {};
+
+ // Big-little architecture.
+ bool big_little = {};
+
+ // Critical temperature in degrees Celsius.
+ float critical_temp_celsius = {};
+
+ // Trip point information.
+ ::fidl::Array<::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo, 16> trip_point_info = {};
+
+ // Operating point information.
+ ::fidl::Array<::llcpp::fuchsia::hardware::thermal::OperatingPoint, 2> opps = {};
+};
+
+// The maximum number of trip points that can be used.
+constexpr uint32_t MAX_TRIP_POINTS = 16u;
+
+// The maximum number of operating points that can be used.
+constexpr uint32_t MAX_DVFS_OPPS = 16u;
+
+// The maximum number of DVFS domains a device can support (one for each cluster in a big-little
+// architecture).
+constexpr uint32_t MAX_DVFS_DOMAINS = 2u;
+
+} // namespace thermal
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo, up_temp_celsius) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo, down_temp_celsius) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo, fan_level) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo, big_cluster_dvfs_opp) == 12);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo, little_cluster_dvfs_opp) == 14);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo, gpu_clk_freq_source) == 16);
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo) == ::llcpp::fuchsia::hardware::thermal::ThermalTemperatureInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::ThermalInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::thermal::ThermalInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalInfo, state) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalInfo, passive_temp_celsius) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalInfo, critical_temp_celsius) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalInfo, max_trip_count) == 12);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalInfo, active_trip) == 16);
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::ThermalInfo) == ::llcpp::fuchsia::hardware::thermal::ThermalInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetInfoResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetInfoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetInfoResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetDeviceInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetDeviceInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetDeviceInfoResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetDeviceInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetDeviceInfoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetDeviceInfoResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoRequest)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoRequest, power_domain) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsInfoResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetTemperatureCelsiusResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetTemperatureCelsiusResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetTemperatureCelsiusResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetTemperatureCelsiusResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetTemperatureCelsiusResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetTemperatureCelsiusResponse, temp) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetStateChangeEventResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetStateChangeEventResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetStateChangeEventResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetStateChangeEventResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetStateChangeEventResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetStateChangeEventResponse, handle) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetStateChangePortResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetStateChangePortResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetStateChangePortResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetStateChangePortResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetStateChangePortResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetStateChangePortResponse, handle) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusRequest)
+ == ::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusRequest, id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusRequest, temp) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::SetTripCelsiusResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointRequest)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointRequest, power_domain) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetDvfsOperatingPointResponse, op_idx) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointRequest)
+ == ::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointRequest, op_idx) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointRequest, power_domain) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::SetDvfsOperatingPointResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::GetFanLevelResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::GetFanLevelResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::GetFanLevelResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::GetFanLevelResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetFanLevelResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::GetFanLevelResponse, fan_level) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelRequest)
+ == ::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelRequest, fan_level) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelResponse)
+ == ::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::Device::SetFanLevelResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::OperatingPointEntry> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::thermal::OperatingPointEntry>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::OperatingPointEntry, freq_hz) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::OperatingPointEntry, volt_uv) == 4);
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::OperatingPointEntry) == ::llcpp::fuchsia::hardware::thermal::OperatingPointEntry::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::OperatingPoint> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::thermal::OperatingPoint>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::OperatingPoint, opp) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::OperatingPoint, latency) == 128);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::OperatingPoint, count) == 132);
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::OperatingPoint) == ::llcpp::fuchsia::hardware::thermal::OperatingPoint::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo, active_cooling) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo, passive_cooling) == 1);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo, gpu_throttling) == 2);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo, num_trip_points) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo, big_little) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo, critical_temp_celsius) == 12);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo, trip_point_info) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo, opps) == 336);
+static_assert(sizeof(::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo) == ::llcpp::fuchsia::hardware::thermal::ThermalDeviceInfo::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-usb-device/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-usb-device/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..2af94d7
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-usb-device/gen/llcpp/fidl.cc
@@ -0,0 +1,1333 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/usb/device/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace usb {
+namespace device {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceSpeed_Ordinal = 0x7a0548ed00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceSpeed_GenOrdinal = 0x623cd7927fb449delu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceSpeedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceSpeedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceDescriptor_Ordinal = 0x16be426a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceDescriptor_GenOrdinal = 0x5f761371f4b9f34alu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceDescriptorRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceDescriptorResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetConfigurationDescriptorSize_Ordinal = 0x2ae4152200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetConfigurationDescriptorSize_GenOrdinal = 0x65912d7d5e3a07c8lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorSizeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetConfigurationDescriptor_Ordinal = 0x67de3f8000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetConfigurationDescriptor_GenOrdinal = 0x1859a4e4421d2036lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStringDescriptor_Ordinal = 0x6bb5f7d600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetStringDescriptor_GenOrdinal = 0x5ff601b3b6891337lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetStringDescriptorRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetStringDescriptorResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetInterface_Ordinal = 0x6fbe7e7700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetInterface_GenOrdinal = 0x45348c50850b641dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetInterfaceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetInterfaceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceId_Ordinal = 0x629986ec00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetDeviceId_GenOrdinal = 0x34a73eef491c2ce0lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceIdResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetHubDeviceId_Ordinal = 0x1508505f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetHubDeviceId_GenOrdinal = 0xce263c86f7bbbcdlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetHubDeviceIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetHubDeviceIdResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetConfiguration_Ordinal = 0x6115919400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetConfiguration_GenOrdinal = 0x73f644382a2335fdlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetConfiguration_Ordinal = 0x43137b500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetConfiguration_GenOrdinal = 0x12bf6e43b045ee9dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetConfigurationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetConfigurationResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetDeviceSpeed_Impl<Device::GetDeviceSpeedResponse>::GetDeviceSpeed_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceSpeedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDeviceSpeedRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceSpeedRequest));
+ ::fidl::DecodedMessage<GetDeviceSpeedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetDeviceSpeed(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetDeviceSpeed Device::SyncClient::GetDeviceSpeed() {
+ return ResultOf::GetDeviceSpeed(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetDeviceSpeed Device::Call::GetDeviceSpeed(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDeviceSpeed(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetDeviceSpeed_Impl<Device::GetDeviceSpeedResponse>::GetDeviceSpeed_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceSpeedRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDeviceSpeedRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDeviceSpeedRequest));
+ ::fidl::DecodedMessage<GetDeviceSpeedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetDeviceSpeed(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetDeviceSpeed Device::SyncClient::GetDeviceSpeed(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceSpeed(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetDeviceSpeed Device::Call::GetDeviceSpeed(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceSpeed(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetDeviceSpeedResponse> Device::InPlace::GetDeviceSpeed(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDeviceSpeedRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDeviceSpeedRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetDeviceSpeedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceSpeedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDeviceSpeedRequest, GetDeviceSpeedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceSpeedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetDeviceDescriptor_Impl<Device::GetDeviceDescriptorResponse>::GetDeviceDescriptor_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceDescriptorRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDeviceDescriptorRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceDescriptorRequest));
+ ::fidl::DecodedMessage<GetDeviceDescriptorRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetDeviceDescriptor(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetDeviceDescriptor Device::SyncClient::GetDeviceDescriptor() {
+ return ResultOf::GetDeviceDescriptor(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetDeviceDescriptor Device::Call::GetDeviceDescriptor(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDeviceDescriptor(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetDeviceDescriptor_Impl<Device::GetDeviceDescriptorResponse>::GetDeviceDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceDescriptorRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDeviceDescriptorRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDeviceDescriptorRequest));
+ ::fidl::DecodedMessage<GetDeviceDescriptorRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetDeviceDescriptor(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetDeviceDescriptor Device::SyncClient::GetDeviceDescriptor(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceDescriptor(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetDeviceDescriptor Device::Call::GetDeviceDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceDescriptor(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetDeviceDescriptorResponse> Device::InPlace::GetDeviceDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDeviceDescriptorRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDeviceDescriptorRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetDeviceDescriptorRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceDescriptorResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDeviceDescriptorRequest, GetDeviceDescriptorResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceDescriptorResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetConfigurationDescriptorSize_Impl<Device::GetConfigurationDescriptorSizeResponse>::GetConfigurationDescriptorSize_Impl(::zx::unowned_channel _client_end, uint8_t config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationDescriptorSizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetConfigurationDescriptorSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetConfigurationDescriptorSizeRequest*>(_write_bytes);
+ _request.config = std::move(config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationDescriptorSizeRequest));
+ ::fidl::DecodedMessage<GetConfigurationDescriptorSizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetConfigurationDescriptorSize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetConfigurationDescriptorSize Device::SyncClient::GetConfigurationDescriptorSize(uint8_t config) {
+ return ResultOf::GetConfigurationDescriptorSize(::zx::unowned_channel(this->channel_), std::move(config));
+}
+
+Device::ResultOf::GetConfigurationDescriptorSize Device::Call::GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, uint8_t config) {
+ return ResultOf::GetConfigurationDescriptorSize(std::move(_client_end), std::move(config));
+}
+
+template <>
+Device::UnownedResultOf::GetConfigurationDescriptorSize_Impl<Device::GetConfigurationDescriptorSizeResponse>::GetConfigurationDescriptorSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetConfigurationDescriptorSizeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetConfigurationDescriptorSizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetConfigurationDescriptorSizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetConfigurationDescriptorSizeRequest*>(_request_buffer.data());
+ _request.config = std::move(config);
+ _request_buffer.set_actual(sizeof(GetConfigurationDescriptorSizeRequest));
+ ::fidl::DecodedMessage<GetConfigurationDescriptorSizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetConfigurationDescriptorSize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetConfigurationDescriptorSize Device::SyncClient::GetConfigurationDescriptorSize(::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetConfigurationDescriptorSize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetConfigurationDescriptorSize Device::Call::GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetConfigurationDescriptorSize(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetConfigurationDescriptorSizeResponse> Device::InPlace::GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetConfigurationDescriptorSizeRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetConfigurationDescriptorSizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetConfigurationDescriptorSizeRequest, GetConfigurationDescriptorSizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetConfigurationDescriptorSizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetConfigurationDescriptor_Impl<Device::GetConfigurationDescriptorResponse>::GetConfigurationDescriptor_Impl(::zx::unowned_channel _client_end, uint8_t config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationDescriptorRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetConfigurationDescriptorRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetConfigurationDescriptorRequest*>(_write_bytes);
+ _request.config = std::move(config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationDescriptorRequest));
+ ::fidl::DecodedMessage<GetConfigurationDescriptorRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetConfigurationDescriptor(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetConfigurationDescriptor Device::SyncClient::GetConfigurationDescriptor(uint8_t config) {
+ return ResultOf::GetConfigurationDescriptor(::zx::unowned_channel(this->channel_), std::move(config));
+}
+
+Device::ResultOf::GetConfigurationDescriptor Device::Call::GetConfigurationDescriptor(::zx::unowned_channel _client_end, uint8_t config) {
+ return ResultOf::GetConfigurationDescriptor(std::move(_client_end), std::move(config));
+}
+
+template <>
+Device::UnownedResultOf::GetConfigurationDescriptor_Impl<Device::GetConfigurationDescriptorResponse>::GetConfigurationDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetConfigurationDescriptorRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetConfigurationDescriptorResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetConfigurationDescriptorRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetConfigurationDescriptorRequest*>(_request_buffer.data());
+ _request.config = std::move(config);
+ _request_buffer.set_actual(sizeof(GetConfigurationDescriptorRequest));
+ ::fidl::DecodedMessage<GetConfigurationDescriptorRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetConfigurationDescriptor(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetConfigurationDescriptor Device::SyncClient::GetConfigurationDescriptor(::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetConfigurationDescriptor(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetConfigurationDescriptor Device::Call::GetConfigurationDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetConfigurationDescriptor(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetConfigurationDescriptorResponse> Device::InPlace::GetConfigurationDescriptor(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetConfigurationDescriptorRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetConfigurationDescriptorRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetConfigurationDescriptorResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetConfigurationDescriptorRequest, GetConfigurationDescriptorResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetConfigurationDescriptorResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetStringDescriptor_Impl<Device::GetStringDescriptorResponse>::GetStringDescriptor_Impl(::zx::unowned_channel _client_end, uint8_t desc_id, uint16_t lang_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStringDescriptorRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetStringDescriptorRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStringDescriptorRequest*>(_write_bytes);
+ _request.desc_id = std::move(desc_id);
+ _request.lang_id = std::move(lang_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetStringDescriptorRequest));
+ ::fidl::DecodedMessage<GetStringDescriptorRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetStringDescriptor(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::GetStringDescriptor Device::SyncClient::GetStringDescriptor(uint8_t desc_id, uint16_t lang_id) {
+ return ResultOf::GetStringDescriptor(::zx::unowned_channel(this->channel_), std::move(desc_id), std::move(lang_id));
+}
+
+Device::ResultOf::GetStringDescriptor Device::Call::GetStringDescriptor(::zx::unowned_channel _client_end, uint8_t desc_id, uint16_t lang_id) {
+ return ResultOf::GetStringDescriptor(std::move(_client_end), std::move(desc_id), std::move(lang_id));
+}
+
+template <>
+Device::UnownedResultOf::GetStringDescriptor_Impl<Device::GetStringDescriptorResponse>::GetStringDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetStringDescriptorRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetStringDescriptorResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetStringDescriptorRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetStringDescriptorRequest*>(_request_buffer.data());
+ _request.desc_id = std::move(desc_id);
+ _request.lang_id = std::move(lang_id);
+ _request_buffer.set_actual(sizeof(GetStringDescriptorRequest));
+ ::fidl::DecodedMessage<GetStringDescriptorRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetStringDescriptor(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetStringDescriptor Device::SyncClient::GetStringDescriptor(::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStringDescriptor(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(desc_id), std::move(lang_id), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetStringDescriptor Device::Call::GetStringDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetStringDescriptor(std::move(_client_end), std::move(_request_buffer), std::move(desc_id), std::move(lang_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetStringDescriptorResponse> Device::InPlace::GetStringDescriptor(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStringDescriptorRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::GetStringDescriptorRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStringDescriptorResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetStringDescriptorRequest, GetStringDescriptorResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetStringDescriptorResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetInterface_Impl<Device::SetInterfaceResponse>::SetInterface_Impl(::zx::unowned_channel _client_end, uint8_t interface_number, uint8_t alt_setting) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetInterfaceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetInterfaceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetInterfaceRequest*>(_write_bytes);
+ _request.interface_number = std::move(interface_number);
+ _request.alt_setting = std::move(alt_setting);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetInterfaceRequest));
+ ::fidl::DecodedMessage<SetInterfaceRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetInterface(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetInterface Device::SyncClient::SetInterface(uint8_t interface_number, uint8_t alt_setting) {
+ return ResultOf::SetInterface(::zx::unowned_channel(this->channel_), std::move(interface_number), std::move(alt_setting));
+}
+
+Device::ResultOf::SetInterface Device::Call::SetInterface(::zx::unowned_channel _client_end, uint8_t interface_number, uint8_t alt_setting) {
+ return ResultOf::SetInterface(std::move(_client_end), std::move(interface_number), std::move(alt_setting));
+}
+
+template <>
+Device::UnownedResultOf::SetInterface_Impl<Device::SetInterfaceResponse>::SetInterface_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetInterfaceRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetInterfaceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetInterfaceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetInterfaceRequest*>(_request_buffer.data());
+ _request.interface_number = std::move(interface_number);
+ _request.alt_setting = std::move(alt_setting);
+ _request_buffer.set_actual(sizeof(SetInterfaceRequest));
+ ::fidl::DecodedMessage<SetInterfaceRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetInterface(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetInterface Device::SyncClient::SetInterface(::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetInterface(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(interface_number), std::move(alt_setting), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetInterface Device::Call::SetInterface(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetInterface(std::move(_client_end), std::move(_request_buffer), std::move(interface_number), std::move(alt_setting), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetInterfaceResponse> Device::InPlace::SetInterface(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetInterfaceRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetInterfaceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetInterfaceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetInterfaceRequest, SetInterfaceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetInterfaceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetDeviceId_Impl<Device::GetDeviceIdResponse>::GetDeviceId_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceIdRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDeviceIdRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceIdRequest));
+ ::fidl::DecodedMessage<GetDeviceIdRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetDeviceId(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetDeviceId Device::SyncClient::GetDeviceId() {
+ return ResultOf::GetDeviceId(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetDeviceId Device::Call::GetDeviceId(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDeviceId(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetDeviceId_Impl<Device::GetDeviceIdResponse>::GetDeviceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDeviceIdRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDeviceIdRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDeviceIdRequest));
+ ::fidl::DecodedMessage<GetDeviceIdRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetDeviceId(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetDeviceId Device::SyncClient::GetDeviceId(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceId(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetDeviceId Device::Call::GetDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDeviceId(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetDeviceIdResponse> Device::InPlace::GetDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDeviceIdRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDeviceIdRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetDeviceIdRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceIdResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDeviceIdRequest, GetDeviceIdResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetDeviceIdResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetHubDeviceId_Impl<Device::GetHubDeviceIdResponse>::GetHubDeviceId_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetHubDeviceIdRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetHubDeviceIdRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetHubDeviceIdRequest));
+ ::fidl::DecodedMessage<GetHubDeviceIdRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetHubDeviceId(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetHubDeviceId Device::SyncClient::GetHubDeviceId() {
+ return ResultOf::GetHubDeviceId(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetHubDeviceId Device::Call::GetHubDeviceId(::zx::unowned_channel _client_end) {
+ return ResultOf::GetHubDeviceId(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetHubDeviceId_Impl<Device::GetHubDeviceIdResponse>::GetHubDeviceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetHubDeviceIdRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetHubDeviceIdRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetHubDeviceIdRequest));
+ ::fidl::DecodedMessage<GetHubDeviceIdRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetHubDeviceId(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetHubDeviceId Device::SyncClient::GetHubDeviceId(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetHubDeviceId(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetHubDeviceId Device::Call::GetHubDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetHubDeviceId(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetHubDeviceIdResponse> Device::InPlace::GetHubDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetHubDeviceIdRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetHubDeviceIdRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetHubDeviceIdRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetHubDeviceIdResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetHubDeviceIdRequest, GetHubDeviceIdResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetHubDeviceIdResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::GetConfiguration_Impl<Device::GetConfigurationResponse>::GetConfiguration_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetConfigurationRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationRequest));
+ ::fidl::DecodedMessage<GetConfigurationRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetConfiguration(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetConfiguration Device::SyncClient::GetConfiguration() {
+ return ResultOf::GetConfiguration(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetConfiguration Device::Call::GetConfiguration(::zx::unowned_channel _client_end) {
+ return ResultOf::GetConfiguration(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetConfiguration_Impl<Device::GetConfigurationResponse>::GetConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetConfigurationRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetConfigurationRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetConfigurationRequest));
+ ::fidl::DecodedMessage<GetConfigurationRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetConfiguration(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetConfiguration Device::SyncClient::GetConfiguration(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetConfiguration(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetConfiguration Device::Call::GetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetConfiguration(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetConfigurationResponse> Device::InPlace::GetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetConfigurationRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetConfigurationRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetConfigurationRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetConfigurationResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetConfigurationRequest, GetConfigurationResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetConfigurationResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetConfiguration_Impl<Device::SetConfigurationResponse>::SetConfiguration_Impl(::zx::unowned_channel _client_end, uint8_t configuration) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetConfigurationRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigurationRequest*>(_write_bytes);
+ _request.configuration = std::move(configuration);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigurationRequest));
+ ::fidl::DecodedMessage<SetConfigurationRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetConfiguration(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetConfiguration Device::SyncClient::SetConfiguration(uint8_t configuration) {
+ return ResultOf::SetConfiguration(::zx::unowned_channel(this->channel_), std::move(configuration));
+}
+
+Device::ResultOf::SetConfiguration Device::Call::SetConfiguration(::zx::unowned_channel _client_end, uint8_t configuration) {
+ return ResultOf::SetConfiguration(std::move(_client_end), std::move(configuration));
+}
+
+template <>
+Device::UnownedResultOf::SetConfiguration_Impl<Device::SetConfigurationResponse>::SetConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t configuration, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetConfigurationRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetConfigurationResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetConfigurationRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigurationRequest*>(_request_buffer.data());
+ _request.configuration = std::move(configuration);
+ _request_buffer.set_actual(sizeof(SetConfigurationRequest));
+ ::fidl::DecodedMessage<SetConfigurationRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetConfiguration(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetConfiguration Device::SyncClient::SetConfiguration(::fidl::BytePart _request_buffer, uint8_t configuration, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfiguration(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetConfiguration Device::Call::SetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t configuration, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfiguration(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetConfigurationResponse> Device::InPlace::SetConfiguration(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetConfigurationRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetConfigurationResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetConfigurationRequest, SetConfigurationResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetConfigurationResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetDeviceSpeed_Ordinal:
+ case kDevice_GetDeviceSpeed_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDeviceSpeedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDeviceSpeed(
+ Interface::GetDeviceSpeedCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetDeviceDescriptor_Ordinal:
+ case kDevice_GetDeviceDescriptor_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDeviceDescriptorRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDeviceDescriptor(
+ Interface::GetDeviceDescriptorCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetConfigurationDescriptorSize_Ordinal:
+ case kDevice_GetConfigurationDescriptorSize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetConfigurationDescriptorSizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetConfigurationDescriptorSize(std::move(message->config),
+ Interface::GetConfigurationDescriptorSizeCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetConfigurationDescriptor_Ordinal:
+ case kDevice_GetConfigurationDescriptor_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetConfigurationDescriptorRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetConfigurationDescriptor(std::move(message->config),
+ Interface::GetConfigurationDescriptorCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetStringDescriptor_Ordinal:
+ case kDevice_GetStringDescriptor_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetStringDescriptorRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetStringDescriptor(std::move(message->desc_id), std::move(message->lang_id),
+ Interface::GetStringDescriptorCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetInterface_Ordinal:
+ case kDevice_SetInterface_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetInterfaceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetInterface(std::move(message->interface_number), std::move(message->alt_setting),
+ Interface::SetInterfaceCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetDeviceId_Ordinal:
+ case kDevice_GetDeviceId_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDeviceIdRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDeviceId(
+ Interface::GetDeviceIdCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetHubDeviceId_Ordinal:
+ case kDevice_GetHubDeviceId_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetHubDeviceIdRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetHubDeviceId(
+ Interface::GetHubDeviceIdCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_GetConfiguration_Ordinal:
+ case kDevice_GetConfiguration_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetConfigurationRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetConfiguration(
+ Interface::GetConfigurationCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetConfiguration_Ordinal:
+ case kDevice_SetConfiguration_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetConfigurationRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetConfiguration(std::move(message->configuration),
+ Interface::SetConfigurationCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetDeviceSpeedCompleterBase::Reply(uint32_t speed) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceSpeedResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetDeviceSpeedResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetDeviceSpeedResponse(
+ ::fidl::DecodedMessage<GetDeviceSpeedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceSpeedResponse::PrimarySize,
+ GetDeviceSpeedResponse::PrimarySize)));
+ _response.speed = std::move(speed);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceSpeedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceSpeedResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetDeviceSpeedCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t speed) {
+ if (_buffer.capacity() < GetDeviceSpeedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetDeviceSpeedResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetDeviceSpeedResponse(
+ ::fidl::DecodedMessage<GetDeviceSpeedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceSpeedResponse::PrimarySize,
+ GetDeviceSpeedResponse::PrimarySize)));
+ _response.speed = std::move(speed);
+ _buffer.set_actual(sizeof(GetDeviceSpeedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceSpeedResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetDeviceSpeedCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceSpeedResponse> params) {
+ Device::SetTransactionHeaderFor::GetDeviceSpeedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetDeviceDescriptorCompleterBase::Reply(::fidl::Array<uint8_t, 18> desc) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceDescriptorResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetDeviceDescriptorResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetDeviceDescriptorResponse(
+ ::fidl::DecodedMessage<GetDeviceDescriptorResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceDescriptorResponse::PrimarySize,
+ GetDeviceDescriptorResponse::PrimarySize)));
+ _response.desc = std::move(desc);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceDescriptorResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceDescriptorResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetDeviceDescriptorCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::Array<uint8_t, 18> desc) {
+ if (_buffer.capacity() < GetDeviceDescriptorResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetDeviceDescriptorResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetDeviceDescriptorResponse(
+ ::fidl::DecodedMessage<GetDeviceDescriptorResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceDescriptorResponse::PrimarySize,
+ GetDeviceDescriptorResponse::PrimarySize)));
+ _response.desc = std::move(desc);
+ _buffer.set_actual(sizeof(GetDeviceDescriptorResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceDescriptorResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetDeviceDescriptorCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceDescriptorResponse> params) {
+ Device::SetTransactionHeaderFor::GetDeviceDescriptorResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetConfigurationDescriptorSizeCompleterBase::Reply(int32_t s, uint16_t size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationDescriptorSizeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetConfigurationDescriptorSizeResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeResponse(
+ ::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetConfigurationDescriptorSizeResponse::PrimarySize,
+ GetConfigurationDescriptorSizeResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.size = std::move(size);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationDescriptorSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetConfigurationDescriptorSizeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint16_t size) {
+ if (_buffer.capacity() < GetConfigurationDescriptorSizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetConfigurationDescriptorSizeResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeResponse(
+ ::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetConfigurationDescriptorSizeResponse::PrimarySize,
+ GetConfigurationDescriptorSizeResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.size = std::move(size);
+ _buffer.set_actual(sizeof(GetConfigurationDescriptorSizeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetConfigurationDescriptorSizeCompleterBase::Reply(::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse> params) {
+ Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetConfigurationDescriptorCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> desc) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationDescriptorResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetConfigurationDescriptorResponse _response = {};
+ Device::SetTransactionHeaderFor::GetConfigurationDescriptorResponse(
+ ::fidl::DecodedMessage<GetConfigurationDescriptorResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetConfigurationDescriptorResponse::PrimarySize,
+ GetConfigurationDescriptorResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.desc = std::move(desc);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetConfigurationDescriptorCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> desc) {
+ if (_buffer.capacity() < GetConfigurationDescriptorResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetConfigurationDescriptorResponse _response = {};
+ Device::SetTransactionHeaderFor::GetConfigurationDescriptorResponse(
+ ::fidl::DecodedMessage<GetConfigurationDescriptorResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetConfigurationDescriptorResponse::PrimarySize,
+ GetConfigurationDescriptorResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.desc = std::move(desc);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetConfigurationDescriptorCompleterBase::Reply(::fidl::DecodedMessage<GetConfigurationDescriptorResponse> params) {
+ Device::SetTransactionHeaderFor::GetConfigurationDescriptorResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetStringDescriptorCompleterBase::Reply(int32_t s, ::fidl::StringView desc, uint16_t actual_lang_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetStringDescriptorResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetStringDescriptorResponse _response = {};
+ Device::SetTransactionHeaderFor::GetStringDescriptorResponse(
+ ::fidl::DecodedMessage<GetStringDescriptorResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStringDescriptorResponse::PrimarySize,
+ GetStringDescriptorResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.desc = std::move(desc);
+ _response.actual_lang_id = std::move(actual_lang_id);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetStringDescriptorCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::StringView desc, uint16_t actual_lang_id) {
+ if (_buffer.capacity() < GetStringDescriptorResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetStringDescriptorResponse _response = {};
+ Device::SetTransactionHeaderFor::GetStringDescriptorResponse(
+ ::fidl::DecodedMessage<GetStringDescriptorResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetStringDescriptorResponse::PrimarySize,
+ GetStringDescriptorResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.desc = std::move(desc);
+ _response.actual_lang_id = std::move(actual_lang_id);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetStringDescriptorCompleterBase::Reply(::fidl::DecodedMessage<GetStringDescriptorResponse> params) {
+ Device::SetTransactionHeaderFor::GetStringDescriptorResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetInterfaceCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetInterfaceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetInterfaceResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetInterfaceResponse(
+ ::fidl::DecodedMessage<SetInterfaceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetInterfaceResponse::PrimarySize,
+ SetInterfaceResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetInterfaceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetInterfaceResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetInterfaceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetInterfaceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetInterfaceResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetInterfaceResponse(
+ ::fidl::DecodedMessage<SetInterfaceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetInterfaceResponse::PrimarySize,
+ SetInterfaceResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetInterfaceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetInterfaceResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetInterfaceCompleterBase::Reply(::fidl::DecodedMessage<SetInterfaceResponse> params) {
+ Device::SetTransactionHeaderFor::SetInterfaceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetDeviceIdCompleterBase::Reply(uint32_t device_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDeviceIdResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetDeviceIdResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetDeviceIdResponse(
+ ::fidl::DecodedMessage<GetDeviceIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceIdResponse::PrimarySize,
+ GetDeviceIdResponse::PrimarySize)));
+ _response.device_id = std::move(device_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDeviceIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceIdResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetDeviceIdCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t device_id) {
+ if (_buffer.capacity() < GetDeviceIdResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetDeviceIdResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetDeviceIdResponse(
+ ::fidl::DecodedMessage<GetDeviceIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDeviceIdResponse::PrimarySize,
+ GetDeviceIdResponse::PrimarySize)));
+ _response.device_id = std::move(device_id);
+ _buffer.set_actual(sizeof(GetDeviceIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetDeviceIdResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetDeviceIdCompleterBase::Reply(::fidl::DecodedMessage<GetDeviceIdResponse> params) {
+ Device::SetTransactionHeaderFor::GetDeviceIdResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetHubDeviceIdCompleterBase::Reply(uint32_t hub_device_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetHubDeviceIdResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetHubDeviceIdResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetHubDeviceIdResponse(
+ ::fidl::DecodedMessage<GetHubDeviceIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetHubDeviceIdResponse::PrimarySize,
+ GetHubDeviceIdResponse::PrimarySize)));
+ _response.hub_device_id = std::move(hub_device_id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetHubDeviceIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetHubDeviceIdResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetHubDeviceIdCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t hub_device_id) {
+ if (_buffer.capacity() < GetHubDeviceIdResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetHubDeviceIdResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetHubDeviceIdResponse(
+ ::fidl::DecodedMessage<GetHubDeviceIdResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetHubDeviceIdResponse::PrimarySize,
+ GetHubDeviceIdResponse::PrimarySize)));
+ _response.hub_device_id = std::move(hub_device_id);
+ _buffer.set_actual(sizeof(GetHubDeviceIdResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetHubDeviceIdResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetHubDeviceIdCompleterBase::Reply(::fidl::DecodedMessage<GetHubDeviceIdResponse> params) {
+ Device::SetTransactionHeaderFor::GetHubDeviceIdResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::GetConfigurationCompleterBase::Reply(uint8_t configuration) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigurationResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetConfigurationResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::GetConfigurationResponse(
+ ::fidl::DecodedMessage<GetConfigurationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetConfigurationResponse::PrimarySize,
+ GetConfigurationResponse::PrimarySize)));
+ _response.configuration = std::move(configuration);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigurationResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetConfigurationResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::GetConfigurationCompleterBase::Reply(::fidl::BytePart _buffer, uint8_t configuration) {
+ if (_buffer.capacity() < GetConfigurationResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetConfigurationResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::GetConfigurationResponse(
+ ::fidl::DecodedMessage<GetConfigurationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetConfigurationResponse::PrimarySize,
+ GetConfigurationResponse::PrimarySize)));
+ _response.configuration = std::move(configuration);
+ _buffer.set_actual(sizeof(GetConfigurationResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetConfigurationResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::GetConfigurationCompleterBase::Reply(::fidl::DecodedMessage<GetConfigurationResponse> params) {
+ Device::SetTransactionHeaderFor::GetConfigurationResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetConfigurationCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetConfigurationResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetConfigurationResponse(
+ ::fidl::DecodedMessage<SetConfigurationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigurationResponse::PrimarySize,
+ SetConfigurationResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigurationResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigurationResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetConfigurationCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetConfigurationResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetConfigurationResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetConfigurationResponse(
+ ::fidl::DecodedMessage<SetConfigurationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigurationResponse::PrimarySize,
+ SetConfigurationResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetConfigurationResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigurationResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetConfigurationCompleterBase::Reply(::fidl::DecodedMessage<SetConfigurationResponse> params) {
+ Device::SetTransactionHeaderFor::SetConfigurationResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetDeviceSpeedRequest(const ::fidl::DecodedMessage<Device::GetDeviceSpeedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceSpeed_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetDeviceSpeedResponse(const ::fidl::DecodedMessage<Device::GetDeviceSpeedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceSpeed_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetDeviceDescriptorRequest(const ::fidl::DecodedMessage<Device::GetDeviceDescriptorRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceDescriptor_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetDeviceDescriptorResponse(const ::fidl::DecodedMessage<Device::GetDeviceDescriptorResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceDescriptor_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeRequest(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorSizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfigurationDescriptorSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetConfigurationDescriptorSizeResponse(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorSizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfigurationDescriptorSize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetConfigurationDescriptorRequest(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfigurationDescriptor_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetConfigurationDescriptorResponse(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfigurationDescriptor_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetStringDescriptorRequest(const ::fidl::DecodedMessage<Device::GetStringDescriptorRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStringDescriptor_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetStringDescriptorResponse(const ::fidl::DecodedMessage<Device::GetStringDescriptorResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetStringDescriptor_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetInterfaceRequest(const ::fidl::DecodedMessage<Device::SetInterfaceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetInterface_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetInterfaceResponse(const ::fidl::DecodedMessage<Device::SetInterfaceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetInterface_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetDeviceIdRequest(const ::fidl::DecodedMessage<Device::GetDeviceIdRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetDeviceIdResponse(const ::fidl::DecodedMessage<Device::GetDeviceIdResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetDeviceId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetHubDeviceIdRequest(const ::fidl::DecodedMessage<Device::GetHubDeviceIdRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetHubDeviceId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetHubDeviceIdResponse(const ::fidl::DecodedMessage<Device::GetHubDeviceIdResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetHubDeviceId_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::GetConfigurationRequest(const ::fidl::DecodedMessage<Device::GetConfigurationRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfiguration_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetConfigurationResponse(const ::fidl::DecodedMessage<Device::GetConfigurationResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetConfiguration_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetConfigurationRequest(const ::fidl::DecodedMessage<Device::SetConfigurationRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetConfiguration_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetConfigurationResponse(const ::fidl::DecodedMessage<Device::SetConfigurationResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetConfiguration_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace device
+} // namespace usb
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-usb-device/gen/llcpp/include/fuchsia/hardware/usb/device/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-usb-device/gen/llcpp/include/fuchsia/hardware/usb/device/llcpp/fidl.h
new file mode 100644
index 0000000..d3065c9
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-usb-device/gen/llcpp/include/fuchsia/hardware/usb/device/llcpp/fidl.h
@@ -0,0 +1,1327 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace usb {
+namespace device {
+
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceSpeedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceSpeedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceDescriptorRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceDescriptorResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorSizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorSizeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetStringDescriptorRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetStringDescriptorResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetInterfaceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetInterfaceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetDeviceIdResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetHubDeviceIdRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetHubDeviceIdResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceGetConfigurationResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetConfigurationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_device_DeviceSetConfigurationResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetDeviceSpeedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t speed;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetDeviceSpeedResponseTable;
+ 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 GetDeviceSpeedRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDeviceDescriptorResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::Array<uint8_t, 18> desc;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetDeviceDescriptorResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ 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 GetDeviceDescriptorRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetConfigurationDescriptorSizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint16_t size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorSizeResponseTable;
+ 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 GetConfigurationDescriptorSizeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint8_t config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorSizeRequestTable;
+ 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 = GetConfigurationDescriptorSizeResponse;
+ };
+
+ struct GetConfigurationDescriptorResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::VectorView<uint8_t> desc;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 65536;
+ 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 GetConfigurationDescriptorRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint8_t config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetConfigurationDescriptorRequestTable;
+ 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 = GetConfigurationDescriptorResponse;
+ };
+
+ struct GetStringDescriptorResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::StringView desc;
+ uint16_t actual_lang_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetStringDescriptorResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 384;
+ 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 GetStringDescriptorRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint8_t desc_id;
+ uint16_t lang_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetStringDescriptorRequestTable;
+ 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 = GetStringDescriptorResponse;
+ };
+
+ struct SetInterfaceResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceSetInterfaceResponseTable;
+ 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 SetInterfaceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint8_t interface_number;
+ uint8_t alt_setting;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceSetInterfaceRequestTable;
+ 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 = SetInterfaceResponse;
+ };
+
+ struct GetDeviceIdResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t device_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetDeviceIdResponseTable;
+ 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 GetDeviceIdRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetHubDeviceIdResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t hub_device_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetHubDeviceIdResponseTable;
+ 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 GetHubDeviceIdRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetConfigurationResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint8_t configuration;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceGetConfigurationResponseTable;
+ 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 GetConfigurationRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetConfigurationResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceSetConfigurationResponseTable;
+ 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 SetConfigurationRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint8_t configuration;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_device_DeviceSetConfigurationRequestTable;
+ 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 = SetConfigurationResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetDeviceSpeed_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceSpeed_Impl(::zx::unowned_channel _client_end);
+ ~GetDeviceSpeed_Impl() = default;
+ GetDeviceSpeed_Impl(GetDeviceSpeed_Impl&& other) = default;
+ GetDeviceSpeed_Impl& operator=(GetDeviceSpeed_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 GetDeviceDescriptor_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceDescriptor_Impl(::zx::unowned_channel _client_end);
+ ~GetDeviceDescriptor_Impl() = default;
+ GetDeviceDescriptor_Impl(GetDeviceDescriptor_Impl&& other) = default;
+ GetDeviceDescriptor_Impl& operator=(GetDeviceDescriptor_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 GetConfigurationDescriptorSize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetConfigurationDescriptorSize_Impl(::zx::unowned_channel _client_end, uint8_t config);
+ ~GetConfigurationDescriptorSize_Impl() = default;
+ GetConfigurationDescriptorSize_Impl(GetConfigurationDescriptorSize_Impl&& other) = default;
+ GetConfigurationDescriptorSize_Impl& operator=(GetConfigurationDescriptorSize_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 GetConfigurationDescriptor_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetConfigurationDescriptor_Impl(::zx::unowned_channel _client_end, uint8_t config);
+ ~GetConfigurationDescriptor_Impl() = default;
+ GetConfigurationDescriptor_Impl(GetConfigurationDescriptor_Impl&& other) = default;
+ GetConfigurationDescriptor_Impl& operator=(GetConfigurationDescriptor_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 GetStringDescriptor_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetStringDescriptor_Impl(::zx::unowned_channel _client_end, uint8_t desc_id, uint16_t lang_id);
+ ~GetStringDescriptor_Impl() = default;
+ GetStringDescriptor_Impl(GetStringDescriptor_Impl&& other) = default;
+ GetStringDescriptor_Impl& operator=(GetStringDescriptor_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 SetInterface_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetInterface_Impl(::zx::unowned_channel _client_end, uint8_t interface_number, uint8_t alt_setting);
+ ~SetInterface_Impl() = default;
+ SetInterface_Impl(SetInterface_Impl&& other) = default;
+ SetInterface_Impl& operator=(SetInterface_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 GetDeviceId_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceId_Impl(::zx::unowned_channel _client_end);
+ ~GetDeviceId_Impl() = default;
+ GetDeviceId_Impl(GetDeviceId_Impl&& other) = default;
+ GetDeviceId_Impl& operator=(GetDeviceId_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 GetHubDeviceId_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetHubDeviceId_Impl(::zx::unowned_channel _client_end);
+ ~GetHubDeviceId_Impl() = default;
+ GetHubDeviceId_Impl(GetHubDeviceId_Impl&& other) = default;
+ GetHubDeviceId_Impl& operator=(GetHubDeviceId_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 GetConfiguration_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetConfiguration_Impl(::zx::unowned_channel _client_end);
+ ~GetConfiguration_Impl() = default;
+ GetConfiguration_Impl(GetConfiguration_Impl&& other) = default;
+ GetConfiguration_Impl& operator=(GetConfiguration_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 SetConfiguration_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetConfiguration_Impl(::zx::unowned_channel _client_end, uint8_t configuration);
+ ~SetConfiguration_Impl() = default;
+ SetConfiguration_Impl(SetConfiguration_Impl&& other) = default;
+ SetConfiguration_Impl& operator=(SetConfiguration_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 GetDeviceSpeed = GetDeviceSpeed_Impl<GetDeviceSpeedResponse>;
+ using GetDeviceDescriptor = GetDeviceDescriptor_Impl<GetDeviceDescriptorResponse>;
+ using GetConfigurationDescriptorSize = GetConfigurationDescriptorSize_Impl<GetConfigurationDescriptorSizeResponse>;
+ using GetConfigurationDescriptor = GetConfigurationDescriptor_Impl<GetConfigurationDescriptorResponse>;
+ using GetStringDescriptor = GetStringDescriptor_Impl<GetStringDescriptorResponse>;
+ using SetInterface = SetInterface_Impl<SetInterfaceResponse>;
+ using GetDeviceId = GetDeviceId_Impl<GetDeviceIdResponse>;
+ using GetHubDeviceId = GetHubDeviceId_Impl<GetHubDeviceIdResponse>;
+ using GetConfiguration = GetConfiguration_Impl<GetConfigurationResponse>;
+ using SetConfiguration = SetConfiguration_Impl<SetConfigurationResponse>;
+ };
+
+ // 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 GetDeviceSpeed_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceSpeed_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDeviceSpeed_Impl() = default;
+ GetDeviceSpeed_Impl(GetDeviceSpeed_Impl&& other) = default;
+ GetDeviceSpeed_Impl& operator=(GetDeviceSpeed_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 GetDeviceDescriptor_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDeviceDescriptor_Impl() = default;
+ GetDeviceDescriptor_Impl(GetDeviceDescriptor_Impl&& other) = default;
+ GetDeviceDescriptor_Impl& operator=(GetDeviceDescriptor_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 GetConfigurationDescriptorSize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetConfigurationDescriptorSize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer);
+ ~GetConfigurationDescriptorSize_Impl() = default;
+ GetConfigurationDescriptorSize_Impl(GetConfigurationDescriptorSize_Impl&& other) = default;
+ GetConfigurationDescriptorSize_Impl& operator=(GetConfigurationDescriptorSize_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 GetConfigurationDescriptor_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetConfigurationDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer);
+ ~GetConfigurationDescriptor_Impl() = default;
+ GetConfigurationDescriptor_Impl(GetConfigurationDescriptor_Impl&& other) = default;
+ GetConfigurationDescriptor_Impl& operator=(GetConfigurationDescriptor_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 GetStringDescriptor_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetStringDescriptor_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer);
+ ~GetStringDescriptor_Impl() = default;
+ GetStringDescriptor_Impl(GetStringDescriptor_Impl&& other) = default;
+ GetStringDescriptor_Impl& operator=(GetStringDescriptor_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 SetInterface_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetInterface_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer);
+ ~SetInterface_Impl() = default;
+ SetInterface_Impl(SetInterface_Impl&& other) = default;
+ SetInterface_Impl& operator=(SetInterface_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 GetDeviceId_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDeviceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDeviceId_Impl() = default;
+ GetDeviceId_Impl(GetDeviceId_Impl&& other) = default;
+ GetDeviceId_Impl& operator=(GetDeviceId_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 GetHubDeviceId_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetHubDeviceId_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetHubDeviceId_Impl() = default;
+ GetHubDeviceId_Impl(GetHubDeviceId_Impl&& other) = default;
+ GetHubDeviceId_Impl& operator=(GetHubDeviceId_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 GetConfiguration_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetConfiguration_Impl() = default;
+ GetConfiguration_Impl(GetConfiguration_Impl&& other) = default;
+ GetConfiguration_Impl& operator=(GetConfiguration_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 SetConfiguration_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t configuration, ::fidl::BytePart _response_buffer);
+ ~SetConfiguration_Impl() = default;
+ SetConfiguration_Impl(SetConfiguration_Impl&& other) = default;
+ SetConfiguration_Impl& operator=(SetConfiguration_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 GetDeviceSpeed = GetDeviceSpeed_Impl<GetDeviceSpeedResponse>;
+ using GetDeviceDescriptor = GetDeviceDescriptor_Impl<GetDeviceDescriptorResponse>;
+ using GetConfigurationDescriptorSize = GetConfigurationDescriptorSize_Impl<GetConfigurationDescriptorSizeResponse>;
+ using GetConfigurationDescriptor = GetConfigurationDescriptor_Impl<GetConfigurationDescriptorResponse>;
+ using GetStringDescriptor = GetStringDescriptor_Impl<GetStringDescriptorResponse>;
+ using SetInterface = SetInterface_Impl<SetInterfaceResponse>;
+ using GetDeviceId = GetDeviceId_Impl<GetDeviceIdResponse>;
+ using GetHubDeviceId = GetHubDeviceId_Impl<GetHubDeviceIdResponse>;
+ using GetConfiguration = GetConfiguration_Impl<GetConfigurationResponse>;
+ using SetConfiguration = SetConfiguration_Impl<SetConfigurationResponse>;
+ };
+
+ 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_; }
+
+ // Returns the speed of the USB device as a usb_speed_t value.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDeviceSpeed GetDeviceSpeed();
+
+ // Returns the speed of the USB device as a usb_speed_t value.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDeviceSpeed GetDeviceSpeed(::fidl::BytePart _response_buffer);
+
+ // Returns the device's USB device descriptor.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDeviceDescriptor GetDeviceDescriptor();
+
+ // Returns the device's USB device descriptor.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDeviceDescriptor GetDeviceDescriptor(::fidl::BytePart _response_buffer);
+
+ // Returns the total size of the USB configuration descriptor for the given configuration.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetConfigurationDescriptorSize GetConfigurationDescriptorSize(uint8_t config);
+
+ // Returns the total size of the USB configuration descriptor for the given configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetConfigurationDescriptorSize GetConfigurationDescriptorSize(::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer);
+
+ // Returns the device's USB configuration descriptor for the given configuration.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetConfigurationDescriptor GetConfigurationDescriptor(uint8_t config);
+
+ // Returns the device's USB configuration descriptor for the given configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetConfigurationDescriptor GetConfigurationDescriptor(::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer);
+
+ // Fetches a string descriptor from the USB device.
+ //
+ // desc_id : The ID of the string descriptor to fetch, or 0 to fetch
+ // the language table instead.
+ //
+ // lang_id : The language ID of the string descriptor to fetch.
+ // If no matching language ID is present in the device's language
+ // ID table, the first entry of the language ID table will
+ // be substituted.
+ // actual_lang_id : The actual language ID of the string fetched, or 0 for
+ // the language ID table.
+ //
+ // The worst case size for the payload of a language ID table should be 252
+ // bytes, meaning that a 256 byte buffer should always be enough to hold any
+ // language ID table.
+ //
+ // The worst case size for a UTF-8 encoded string descriptor payload should be
+ // 378 bytes (126 UTF-16 code units with a worst case expansion factor of 3)
+ // Allocates 456 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetStringDescriptor GetStringDescriptor(uint8_t desc_id, uint16_t lang_id);
+
+ // Fetches a string descriptor from the USB device.
+ //
+ // desc_id : The ID of the string descriptor to fetch, or 0 to fetch
+ // the language table instead.
+ //
+ // lang_id : The language ID of the string descriptor to fetch.
+ // If no matching language ID is present in the device's language
+ // ID table, the first entry of the language ID table will
+ // be substituted.
+ // actual_lang_id : The actual language ID of the string fetched, or 0 for
+ // the language ID table.
+ //
+ // The worst case size for the payload of a language ID table should be 252
+ // bytes, meaning that a 256 byte buffer should always be enough to hold any
+ // language ID table.
+ //
+ // The worst case size for a UTF-8 encoded string descriptor payload should be
+ // 378 bytes (126 UTF-16 code units with a worst case expansion factor of 3)
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetStringDescriptor GetStringDescriptor(::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer);
+
+ // Selects an alternate setting for an interface on a USB device.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetInterface SetInterface(uint8_t interface_number, uint8_t alt_setting);
+
+ // Selects an alternate setting for an interface on a USB device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetInterface SetInterface(::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer);
+
+ // Returns an implementation specific device ID for a USB device.
+ // For informational purposes only.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetDeviceId GetDeviceId();
+
+ // Returns an implementation specific device ID for a USB device.
+ // For informational purposes only.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDeviceId GetDeviceId(::fidl::BytePart _response_buffer);
+
+ // Returns the implementation specific device ID for the hub that a USB device is connected to.
+ // For informational purposes only.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetHubDeviceId GetHubDeviceId();
+
+ // Returns the implementation specific device ID for the hub that a USB device is connected to.
+ // For informational purposes only.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetHubDeviceId GetHubDeviceId(::fidl::BytePart _response_buffer);
+
+ // Returns the device's current configuration.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetConfiguration GetConfiguration();
+
+ // Returns the device's current configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetConfiguration GetConfiguration(::fidl::BytePart _response_buffer);
+
+ // Sets the device's current configuration.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetConfiguration SetConfiguration(uint8_t configuration);
+
+ // Sets the device's current configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetConfiguration SetConfiguration(::fidl::BytePart _request_buffer, uint8_t configuration, ::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:
+
+ // Returns the speed of the USB device as a usb_speed_t value.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDeviceSpeed GetDeviceSpeed(::zx::unowned_channel _client_end);
+
+ // Returns the speed of the USB device as a usb_speed_t value.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDeviceSpeed GetDeviceSpeed(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns the device's USB device descriptor.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDeviceDescriptor GetDeviceDescriptor(::zx::unowned_channel _client_end);
+
+ // Returns the device's USB device descriptor.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDeviceDescriptor GetDeviceDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns the total size of the USB configuration descriptor for the given configuration.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetConfigurationDescriptorSize GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, uint8_t config);
+
+ // Returns the total size of the USB configuration descriptor for the given configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetConfigurationDescriptorSize GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer);
+
+ // Returns the device's USB configuration descriptor for the given configuration.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetConfigurationDescriptor GetConfigurationDescriptor(::zx::unowned_channel _client_end, uint8_t config);
+
+ // Returns the device's USB configuration descriptor for the given configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetConfigurationDescriptor GetConfigurationDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t config, ::fidl::BytePart _response_buffer);
+
+ // Fetches a string descriptor from the USB device.
+ //
+ // desc_id : The ID of the string descriptor to fetch, or 0 to fetch
+ // the language table instead.
+ //
+ // lang_id : The language ID of the string descriptor to fetch.
+ // If no matching language ID is present in the device's language
+ // ID table, the first entry of the language ID table will
+ // be substituted.
+ // actual_lang_id : The actual language ID of the string fetched, or 0 for
+ // the language ID table.
+ //
+ // The worst case size for the payload of a language ID table should be 252
+ // bytes, meaning that a 256 byte buffer should always be enough to hold any
+ // language ID table.
+ //
+ // The worst case size for a UTF-8 encoded string descriptor payload should be
+ // 378 bytes (126 UTF-16 code units with a worst case expansion factor of 3)
+ // Allocates 456 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetStringDescriptor GetStringDescriptor(::zx::unowned_channel _client_end, uint8_t desc_id, uint16_t lang_id);
+
+ // Fetches a string descriptor from the USB device.
+ //
+ // desc_id : The ID of the string descriptor to fetch, or 0 to fetch
+ // the language table instead.
+ //
+ // lang_id : The language ID of the string descriptor to fetch.
+ // If no matching language ID is present in the device's language
+ // ID table, the first entry of the language ID table will
+ // be substituted.
+ // actual_lang_id : The actual language ID of the string fetched, or 0 for
+ // the language ID table.
+ //
+ // The worst case size for the payload of a language ID table should be 252
+ // bytes, meaning that a 256 byte buffer should always be enough to hold any
+ // language ID table.
+ //
+ // The worst case size for a UTF-8 encoded string descriptor payload should be
+ // 378 bytes (126 UTF-16 code units with a worst case expansion factor of 3)
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetStringDescriptor GetStringDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t desc_id, uint16_t lang_id, ::fidl::BytePart _response_buffer);
+
+ // Selects an alternate setting for an interface on a USB device.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetInterface SetInterface(::zx::unowned_channel _client_end, uint8_t interface_number, uint8_t alt_setting);
+
+ // Selects an alternate setting for an interface on a USB device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetInterface SetInterface(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t interface_number, uint8_t alt_setting, ::fidl::BytePart _response_buffer);
+
+ // Returns an implementation specific device ID for a USB device.
+ // For informational purposes only.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetDeviceId GetDeviceId(::zx::unowned_channel _client_end);
+
+ // Returns an implementation specific device ID for a USB device.
+ // For informational purposes only.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDeviceId GetDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns the implementation specific device ID for the hub that a USB device is connected to.
+ // For informational purposes only.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetHubDeviceId GetHubDeviceId(::zx::unowned_channel _client_end);
+
+ // Returns the implementation specific device ID for the hub that a USB device is connected to.
+ // For informational purposes only.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetHubDeviceId GetHubDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns the device's current configuration.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetConfiguration GetConfiguration(::zx::unowned_channel _client_end);
+
+ // Returns the device's current configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetConfiguration GetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets the device's current configuration.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetConfiguration SetConfiguration(::zx::unowned_channel _client_end, uint8_t configuration);
+
+ // Sets the device's current configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetConfiguration SetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint8_t configuration, ::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:
+
+ // Returns the speed of the USB device as a usb_speed_t value.
+ static ::fidl::DecodeResult<GetDeviceSpeedResponse> GetDeviceSpeed(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns the device's USB device descriptor.
+ static ::fidl::DecodeResult<GetDeviceDescriptorResponse> GetDeviceDescriptor(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns the total size of the USB configuration descriptor for the given configuration.
+ static ::fidl::DecodeResult<GetConfigurationDescriptorSizeResponse> GetConfigurationDescriptorSize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetConfigurationDescriptorSizeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Returns the device's USB configuration descriptor for the given configuration.
+ static ::fidl::DecodeResult<GetConfigurationDescriptorResponse> GetConfigurationDescriptor(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetConfigurationDescriptorRequest> params, ::fidl::BytePart response_buffer);
+
+ // Fetches a string descriptor from the USB device.
+ //
+ // desc_id : The ID of the string descriptor to fetch, or 0 to fetch
+ // the language table instead.
+ //
+ // lang_id : The language ID of the string descriptor to fetch.
+ // If no matching language ID is present in the device's language
+ // ID table, the first entry of the language ID table will
+ // be substituted.
+ // actual_lang_id : The actual language ID of the string fetched, or 0 for
+ // the language ID table.
+ //
+ // The worst case size for the payload of a language ID table should be 252
+ // bytes, meaning that a 256 byte buffer should always be enough to hold any
+ // language ID table.
+ //
+ // The worst case size for a UTF-8 encoded string descriptor payload should be
+ // 378 bytes (126 UTF-16 code units with a worst case expansion factor of 3)
+ static ::fidl::DecodeResult<GetStringDescriptorResponse> GetStringDescriptor(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetStringDescriptorRequest> params, ::fidl::BytePart response_buffer);
+
+ // Selects an alternate setting for an interface on a USB device.
+ static ::fidl::DecodeResult<SetInterfaceResponse> SetInterface(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetInterfaceRequest> params, ::fidl::BytePart response_buffer);
+
+ // Returns an implementation specific device ID for a USB device.
+ // For informational purposes only.
+ static ::fidl::DecodeResult<GetDeviceIdResponse> GetDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns the implementation specific device ID for the hub that a USB device is connected to.
+ // For informational purposes only.
+ static ::fidl::DecodeResult<GetHubDeviceIdResponse> GetHubDeviceId(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns the device's current configuration.
+ static ::fidl::DecodeResult<GetConfigurationResponse> GetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets the device's current configuration.
+ static ::fidl::DecodeResult<SetConfigurationResponse> SetConfiguration(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetDeviceSpeedCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t speed);
+ void Reply(::fidl::BytePart _buffer, uint32_t speed);
+ void Reply(::fidl::DecodedMessage<GetDeviceSpeedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDeviceSpeedCompleter = ::fidl::Completer<GetDeviceSpeedCompleterBase>;
+
+ virtual void GetDeviceSpeed(GetDeviceSpeedCompleter::Sync _completer) = 0;
+
+ class GetDeviceDescriptorCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::Array<uint8_t, 18> desc);
+ void Reply(::fidl::BytePart _buffer, ::fidl::Array<uint8_t, 18> desc);
+ void Reply(::fidl::DecodedMessage<GetDeviceDescriptorResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDeviceDescriptorCompleter = ::fidl::Completer<GetDeviceDescriptorCompleterBase>;
+
+ virtual void GetDeviceDescriptor(GetDeviceDescriptorCompleter::Sync _completer) = 0;
+
+ class GetConfigurationDescriptorSizeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint16_t size);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint16_t size);
+ void Reply(::fidl::DecodedMessage<GetConfigurationDescriptorSizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetConfigurationDescriptorSizeCompleter = ::fidl::Completer<GetConfigurationDescriptorSizeCompleterBase>;
+
+ virtual void GetConfigurationDescriptorSize(uint8_t config, GetConfigurationDescriptorSizeCompleter::Sync _completer) = 0;
+
+ class GetConfigurationDescriptorCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::VectorView<uint8_t> desc);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> desc);
+ void Reply(::fidl::DecodedMessage<GetConfigurationDescriptorResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetConfigurationDescriptorCompleter = ::fidl::Completer<GetConfigurationDescriptorCompleterBase>;
+
+ virtual void GetConfigurationDescriptor(uint8_t config, GetConfigurationDescriptorCompleter::Sync _completer) = 0;
+
+ class GetStringDescriptorCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::StringView desc, uint16_t actual_lang_id);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::StringView desc, uint16_t actual_lang_id);
+ void Reply(::fidl::DecodedMessage<GetStringDescriptorResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetStringDescriptorCompleter = ::fidl::Completer<GetStringDescriptorCompleterBase>;
+
+ virtual void GetStringDescriptor(uint8_t desc_id, uint16_t lang_id, GetStringDescriptorCompleter::Sync _completer) = 0;
+
+ class SetInterfaceCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetInterfaceResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetInterfaceCompleter = ::fidl::Completer<SetInterfaceCompleterBase>;
+
+ virtual void SetInterface(uint8_t interface_number, uint8_t alt_setting, SetInterfaceCompleter::Sync _completer) = 0;
+
+ class GetDeviceIdCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t device_id);
+ void Reply(::fidl::BytePart _buffer, uint32_t device_id);
+ void Reply(::fidl::DecodedMessage<GetDeviceIdResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDeviceIdCompleter = ::fidl::Completer<GetDeviceIdCompleterBase>;
+
+ virtual void GetDeviceId(GetDeviceIdCompleter::Sync _completer) = 0;
+
+ class GetHubDeviceIdCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t hub_device_id);
+ void Reply(::fidl::BytePart _buffer, uint32_t hub_device_id);
+ void Reply(::fidl::DecodedMessage<GetHubDeviceIdResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetHubDeviceIdCompleter = ::fidl::Completer<GetHubDeviceIdCompleterBase>;
+
+ virtual void GetHubDeviceId(GetHubDeviceIdCompleter::Sync _completer) = 0;
+
+ class GetConfigurationCompleterBase : public _Base {
+ public:
+ void Reply(uint8_t configuration);
+ void Reply(::fidl::BytePart _buffer, uint8_t configuration);
+ void Reply(::fidl::DecodedMessage<GetConfigurationResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetConfigurationCompleter = ::fidl::Completer<GetConfigurationCompleterBase>;
+
+ virtual void GetConfiguration(GetConfigurationCompleter::Sync _completer) = 0;
+
+ class SetConfigurationCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetConfigurationResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetConfigurationCompleter = ::fidl::Completer<SetConfigurationCompleterBase>;
+
+ virtual void SetConfiguration(uint8_t configuration, SetConfigurationCompleter::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 GetDeviceSpeedRequest(const ::fidl::DecodedMessage<Device::GetDeviceSpeedRequest>& _msg);
+ static void GetDeviceSpeedResponse(const ::fidl::DecodedMessage<Device::GetDeviceSpeedResponse>& _msg);
+ static void GetDeviceDescriptorRequest(const ::fidl::DecodedMessage<Device::GetDeviceDescriptorRequest>& _msg);
+ static void GetDeviceDescriptorResponse(const ::fidl::DecodedMessage<Device::GetDeviceDescriptorResponse>& _msg);
+ static void GetConfigurationDescriptorSizeRequest(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorSizeRequest>& _msg);
+ static void GetConfigurationDescriptorSizeResponse(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorSizeResponse>& _msg);
+ static void GetConfigurationDescriptorRequest(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorRequest>& _msg);
+ static void GetConfigurationDescriptorResponse(const ::fidl::DecodedMessage<Device::GetConfigurationDescriptorResponse>& _msg);
+ static void GetStringDescriptorRequest(const ::fidl::DecodedMessage<Device::GetStringDescriptorRequest>& _msg);
+ static void GetStringDescriptorResponse(const ::fidl::DecodedMessage<Device::GetStringDescriptorResponse>& _msg);
+ static void SetInterfaceRequest(const ::fidl::DecodedMessage<Device::SetInterfaceRequest>& _msg);
+ static void SetInterfaceResponse(const ::fidl::DecodedMessage<Device::SetInterfaceResponse>& _msg);
+ static void GetDeviceIdRequest(const ::fidl::DecodedMessage<Device::GetDeviceIdRequest>& _msg);
+ static void GetDeviceIdResponse(const ::fidl::DecodedMessage<Device::GetDeviceIdResponse>& _msg);
+ static void GetHubDeviceIdRequest(const ::fidl::DecodedMessage<Device::GetHubDeviceIdRequest>& _msg);
+ static void GetHubDeviceIdResponse(const ::fidl::DecodedMessage<Device::GetHubDeviceIdResponse>& _msg);
+ static void GetConfigurationRequest(const ::fidl::DecodedMessage<Device::GetConfigurationRequest>& _msg);
+ static void GetConfigurationResponse(const ::fidl::DecodedMessage<Device::GetConfigurationResponse>& _msg);
+ static void SetConfigurationRequest(const ::fidl::DecodedMessage<Device::SetConfigurationRequest>& _msg);
+ static void SetConfigurationResponse(const ::fidl::DecodedMessage<Device::SetConfigurationResponse>& _msg);
+ };
+};
+
+// See GetStringDescriptor description below
+constexpr uint32_t MAX_STRING_DESC_SIZE = 384u;
+
+// UINT16_MAX
+constexpr uint32_t MAX_CONFIG_DESC_SIZE = 65536u;
+
+// sizeof(usb_device_descriptor_t)
+constexpr uint32_t DEVICE_DESC_SIZE = 18u;
+
+} // namespace device
+} // namespace usb
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceSpeedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceSpeedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceSpeedResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceSpeedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceSpeedResponse, speed) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceDescriptorResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceDescriptorResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceDescriptorResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceDescriptorResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceDescriptorResponse, desc) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeRequest)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeRequest, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorSizeResponse, size) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorRequest)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorRequest, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationDescriptorResponse, desc) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorRequest)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorRequest, desc_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorRequest, lang_id) == 18);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorResponse, desc) == 24);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetStringDescriptorResponse, actual_lang_id) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceRequest)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceRequest, interface_number) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceRequest, alt_setting) == 17);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::SetInterfaceResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceIdResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceIdResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceIdResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceIdResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetDeviceIdResponse, device_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetHubDeviceIdResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetHubDeviceIdResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetHubDeviceIdResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetHubDeviceIdResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetHubDeviceIdResponse, hub_device_id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::GetConfigurationResponse, configuration) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationRequest)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationRequest, configuration) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationResponse)
+ == ::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::device::Device::SetConfigurationResponse, s) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-usb-peripheral-block/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-usb-peripheral-block/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..4b48d81
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-usb-peripheral-block/gen/llcpp/fidl.cc
@@ -0,0 +1,415 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/usb/peripheral/block/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace usb {
+namespace peripheral {
+namespace block {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_EnableWritebackCache_Ordinal = 0x2b47735200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_EnableWritebackCache_GenOrdinal = 0x34283a6794f49dc0lu;
+extern "C" const fidl_type_t fuchsia_hardware_usb_peripheral_block_DeviceEnableWritebackCacheResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_DisableWritebackCache_Ordinal = 0x2e4207e900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_DisableWritebackCache_GenOrdinal = 0x39e864cc9ab523alu;
+extern "C" const fidl_type_t fuchsia_hardware_usb_peripheral_block_DeviceDisableWritebackCacheResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetWritebackCacheReported_Ordinal = 0x340bd79400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetWritebackCacheReported_GenOrdinal = 0x43c6f4d0035ed0b5lu;
+extern "C" const fidl_type_t fuchsia_hardware_usb_peripheral_block_DeviceSetWritebackCacheReportedRequestTable;
+extern "C" const fidl_type_t fuchsia_hardware_usb_peripheral_block_DeviceSetWritebackCacheReportedResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::EnableWritebackCache_Impl<Device::EnableWritebackCacheResponse>::EnableWritebackCache_Impl(zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EnableWritebackCacheRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, EnableWritebackCacheRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(EnableWritebackCacheRequest));
+ ::fidl::DecodedMessage<EnableWritebackCacheRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::EnableWritebackCache(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::EnableWritebackCache Device::SyncClient::EnableWritebackCache() {
+ return ResultOf::EnableWritebackCache(zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::EnableWritebackCache Device::Call::EnableWritebackCache(zx::unowned_channel _client_end) {
+ return ResultOf::EnableWritebackCache(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::EnableWritebackCache_Impl<Device::EnableWritebackCacheResponse>::EnableWritebackCache_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(EnableWritebackCacheRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, EnableWritebackCacheRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(EnableWritebackCacheRequest));
+ ::fidl::DecodedMessage<EnableWritebackCacheRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::EnableWritebackCache(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::EnableWritebackCache Device::SyncClient::EnableWritebackCache(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EnableWritebackCache(zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::EnableWritebackCache Device::Call::EnableWritebackCache(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EnableWritebackCache(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::EnableWritebackCacheResponse> Device::InPlace::EnableWritebackCache(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(EnableWritebackCacheRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<EnableWritebackCacheRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::EnableWritebackCacheRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::EnableWritebackCacheResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<EnableWritebackCacheRequest, EnableWritebackCacheResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::EnableWritebackCacheResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::DisableWritebackCache_Impl<Device::DisableWritebackCacheResponse>::DisableWritebackCache_Impl(zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DisableWritebackCacheRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DisableWritebackCacheRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DisableWritebackCacheRequest));
+ ::fidl::DecodedMessage<DisableWritebackCacheRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::DisableWritebackCache(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::DisableWritebackCache Device::SyncClient::DisableWritebackCache() {
+ return ResultOf::DisableWritebackCache(zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::DisableWritebackCache Device::Call::DisableWritebackCache(zx::unowned_channel _client_end) {
+ return ResultOf::DisableWritebackCache(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::DisableWritebackCache_Impl<Device::DisableWritebackCacheResponse>::DisableWritebackCache_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DisableWritebackCacheRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DisableWritebackCacheRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DisableWritebackCacheRequest));
+ ::fidl::DecodedMessage<DisableWritebackCacheRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::DisableWritebackCache(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::DisableWritebackCache Device::SyncClient::DisableWritebackCache(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DisableWritebackCache(zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::DisableWritebackCache Device::Call::DisableWritebackCache(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DisableWritebackCache(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::DisableWritebackCacheResponse> Device::InPlace::DisableWritebackCache(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DisableWritebackCacheRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DisableWritebackCacheRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::DisableWritebackCacheRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::DisableWritebackCacheResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DisableWritebackCacheRequest, DisableWritebackCacheResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::DisableWritebackCacheResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::SetWritebackCacheReported_Impl<Device::SetWritebackCacheReportedResponse>::SetWritebackCacheReported_Impl(zx::unowned_channel _client_end, bool report) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetWritebackCacheReportedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetWritebackCacheReportedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetWritebackCacheReportedRequest*>(_write_bytes);
+ _request.report = std::move(report);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetWritebackCacheReportedRequest));
+ ::fidl::DecodedMessage<SetWritebackCacheReportedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::SetWritebackCacheReported(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetWritebackCacheReported Device::SyncClient::SetWritebackCacheReported(bool report) {
+ return ResultOf::SetWritebackCacheReported(zx::unowned_channel(this->channel_), std::move(report));
+}
+
+Device::ResultOf::SetWritebackCacheReported Device::Call::SetWritebackCacheReported(zx::unowned_channel _client_end, bool report) {
+ return ResultOf::SetWritebackCacheReported(std::move(_client_end), std::move(report));
+}
+
+template <>
+Device::UnownedResultOf::SetWritebackCacheReported_Impl<Device::SetWritebackCacheReportedResponse>::SetWritebackCacheReported_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool report, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetWritebackCacheReportedRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetWritebackCacheReportedResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetWritebackCacheReportedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetWritebackCacheReportedRequest*>(_request_buffer.data());
+ _request.report = std::move(report);
+ _request_buffer.set_actual(sizeof(SetWritebackCacheReportedRequest));
+ ::fidl::DecodedMessage<SetWritebackCacheReportedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::SetWritebackCacheReported(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetWritebackCacheReported Device::SyncClient::SetWritebackCacheReported(::fidl::BytePart _request_buffer, bool report, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetWritebackCacheReported(zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(report), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetWritebackCacheReported Device::Call::SetWritebackCacheReported(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool report, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetWritebackCacheReported(std::move(_client_end), std::move(_request_buffer), std::move(report), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetWritebackCacheReportedResponse> Device::InPlace::SetWritebackCacheReported(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetWritebackCacheReportedRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetWritebackCacheReportedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetWritebackCacheReportedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetWritebackCacheReportedRequest, SetWritebackCacheReportedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetWritebackCacheReportedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ switch (hdr->ordinal) {
+ case kDevice_EnableWritebackCache_Ordinal:
+ case kDevice_EnableWritebackCache_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EnableWritebackCacheRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->EnableWritebackCache(
+ Interface::EnableWritebackCacheCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_DisableWritebackCache_Ordinal:
+ case kDevice_DisableWritebackCache_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DisableWritebackCacheRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->DisableWritebackCache(
+ Interface::DisableWritebackCacheCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetWritebackCacheReported_Ordinal:
+ case kDevice_SetWritebackCacheReported_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetWritebackCacheReportedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetWritebackCacheReported(std::move(message->report),
+ Interface::SetWritebackCacheReportedCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::EnableWritebackCacheCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EnableWritebackCacheResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<EnableWritebackCacheResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::EnableWritebackCacheResponse(
+ ::fidl::DecodedMessage<EnableWritebackCacheResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EnableWritebackCacheResponse::PrimarySize,
+ EnableWritebackCacheResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(EnableWritebackCacheResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EnableWritebackCacheResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::EnableWritebackCacheCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < EnableWritebackCacheResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<EnableWritebackCacheResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::EnableWritebackCacheResponse(
+ ::fidl::DecodedMessage<EnableWritebackCacheResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EnableWritebackCacheResponse::PrimarySize,
+ EnableWritebackCacheResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(EnableWritebackCacheResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EnableWritebackCacheResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::EnableWritebackCacheCompleterBase::Reply(::fidl::DecodedMessage<EnableWritebackCacheResponse> params) {
+ Device::SetTransactionHeaderFor::EnableWritebackCacheResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::DisableWritebackCacheCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DisableWritebackCacheResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DisableWritebackCacheResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::DisableWritebackCacheResponse(
+ ::fidl::DecodedMessage<DisableWritebackCacheResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DisableWritebackCacheResponse::PrimarySize,
+ DisableWritebackCacheResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DisableWritebackCacheResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DisableWritebackCacheResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::DisableWritebackCacheCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < DisableWritebackCacheResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DisableWritebackCacheResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::DisableWritebackCacheResponse(
+ ::fidl::DecodedMessage<DisableWritebackCacheResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DisableWritebackCacheResponse::PrimarySize,
+ DisableWritebackCacheResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(DisableWritebackCacheResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DisableWritebackCacheResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::DisableWritebackCacheCompleterBase::Reply(::fidl::DecodedMessage<DisableWritebackCacheResponse> params) {
+ Device::SetTransactionHeaderFor::DisableWritebackCacheResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::SetWritebackCacheReportedCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetWritebackCacheReportedResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetWritebackCacheReportedResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::SetWritebackCacheReportedResponse(
+ ::fidl::DecodedMessage<SetWritebackCacheReportedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetWritebackCacheReportedResponse::PrimarySize,
+ SetWritebackCacheReportedResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetWritebackCacheReportedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetWritebackCacheReportedResponse>(std::move(_response_bytes)));
+}
+
+void Device::Interface::SetWritebackCacheReportedCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetWritebackCacheReportedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetWritebackCacheReportedResponse*>(_buffer.data());
+ Device::SetTransactionHeaderFor::SetWritebackCacheReportedResponse(
+ ::fidl::DecodedMessage<SetWritebackCacheReportedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetWritebackCacheReportedResponse::PrimarySize,
+ SetWritebackCacheReportedResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetWritebackCacheReportedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetWritebackCacheReportedResponse>(std::move(_buffer)));
+}
+
+void Device::Interface::SetWritebackCacheReportedCompleterBase::Reply(::fidl::DecodedMessage<SetWritebackCacheReportedResponse> params) {
+ Device::SetTransactionHeaderFor::SetWritebackCacheReportedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Device::SetTransactionHeaderFor::EnableWritebackCacheRequest(const ::fidl::DecodedMessage<Device::EnableWritebackCacheRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_EnableWritebackCache_Ordinal);
+}
+void Device::SetTransactionHeaderFor::EnableWritebackCacheResponse(const ::fidl::DecodedMessage<Device::EnableWritebackCacheResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_EnableWritebackCache_Ordinal);
+}
+
+void Device::SetTransactionHeaderFor::DisableWritebackCacheRequest(const ::fidl::DecodedMessage<Device::DisableWritebackCacheRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_DisableWritebackCache_Ordinal);
+}
+void Device::SetTransactionHeaderFor::DisableWritebackCacheResponse(const ::fidl::DecodedMessage<Device::DisableWritebackCacheResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_DisableWritebackCache_Ordinal);
+}
+
+void Device::SetTransactionHeaderFor::SetWritebackCacheReportedRequest(const ::fidl::DecodedMessage<Device::SetWritebackCacheReportedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetWritebackCacheReported_Ordinal);
+}
+void Device::SetTransactionHeaderFor::SetWritebackCacheReportedResponse(const ::fidl::DecodedMessage<Device::SetWritebackCacheReportedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetWritebackCacheReported_Ordinal);
+}
+
+} // namespace block
+} // namespace peripheral
+} // namespace usb
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-usb-peripheral-block/gen/llcpp/include/fuchsia/hardware/usb/peripheral/block/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-usb-peripheral-block/gen/llcpp/include/fuchsia/hardware/usb/peripheral/block/llcpp/fidl.h
new file mode 100644
index 0000000..f628187
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-usb-peripheral-block/gen/llcpp/include/fuchsia/hardware/usb/peripheral/block/llcpp/fidl.h
@@ -0,0 +1,492 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace usb {
+namespace peripheral {
+namespace block {
+
+class Device;
+
+extern "C" const fidl_type_t fuchsia_hardware_usb_peripheral_block_DeviceEnableWritebackCacheResponseTable;
+extern "C" const fidl_type_t fuchsia_hardware_usb_peripheral_block_DeviceDisableWritebackCacheResponseTable;
+extern "C" const fidl_type_t fuchsia_hardware_usb_peripheral_block_DeviceSetWritebackCacheReportedRequestTable;
+extern "C" const fidl_type_t fuchsia_hardware_usb_peripheral_block_DeviceSetWritebackCacheReportedResponseTable;
+
+// Represents a simulated USB block device whose cache can be controlled.
+// This allows for integration testing of USB mass storage devices
+// both with and without caches.
+class Device final {
+ Device() = delete;
+ public:
+
+ struct EnableWritebackCacheResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &fuchsia_hardware_usb_peripheral_block_DeviceEnableWritebackCacheResponseTable;
+ 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 ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using EnableWritebackCacheRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DisableWritebackCacheResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &fuchsia_hardware_usb_peripheral_block_DeviceDisableWritebackCacheResponseTable;
+ 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 ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DisableWritebackCacheRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetWritebackCacheReportedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &fuchsia_hardware_usb_peripheral_block_DeviceSetWritebackCacheReportedResponseTable;
+ 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 ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SetWritebackCacheReportedRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool report;
+
+ static constexpr const fidl_type_t* Type = &fuchsia_hardware_usb_peripheral_block_DeviceSetWritebackCacheReportedRequestTable;
+ 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 ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = SetWritebackCacheReportedResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class EnableWritebackCache_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ EnableWritebackCache_Impl(zx::unowned_channel _client_end);
+ ~EnableWritebackCache_Impl() = default;
+ EnableWritebackCache_Impl(EnableWritebackCache_Impl&& other) = default;
+ EnableWritebackCache_Impl& operator=(EnableWritebackCache_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 DisableWritebackCache_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ DisableWritebackCache_Impl(zx::unowned_channel _client_end);
+ ~DisableWritebackCache_Impl() = default;
+ DisableWritebackCache_Impl(DisableWritebackCache_Impl&& other) = default;
+ DisableWritebackCache_Impl& operator=(DisableWritebackCache_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 SetWritebackCacheReported_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetWritebackCacheReported_Impl(zx::unowned_channel _client_end, bool report);
+ ~SetWritebackCacheReported_Impl() = default;
+ SetWritebackCacheReported_Impl(SetWritebackCacheReported_Impl&& other) = default;
+ SetWritebackCacheReported_Impl& operator=(SetWritebackCacheReported_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 EnableWritebackCache = EnableWritebackCache_Impl<EnableWritebackCacheResponse>;
+ using DisableWritebackCache = DisableWritebackCache_Impl<DisableWritebackCacheResponse>;
+ using SetWritebackCacheReported = SetWritebackCacheReported_Impl<SetWritebackCacheReportedResponse>;
+ };
+
+ // 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 EnableWritebackCache_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ EnableWritebackCache_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~EnableWritebackCache_Impl() = default;
+ EnableWritebackCache_Impl(EnableWritebackCache_Impl&& other) = default;
+ EnableWritebackCache_Impl& operator=(EnableWritebackCache_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 DisableWritebackCache_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ DisableWritebackCache_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~DisableWritebackCache_Impl() = default;
+ DisableWritebackCache_Impl(DisableWritebackCache_Impl&& other) = default;
+ DisableWritebackCache_Impl& operator=(DisableWritebackCache_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 SetWritebackCacheReported_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetWritebackCacheReported_Impl(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool report, ::fidl::BytePart _response_buffer);
+ ~SetWritebackCacheReported_Impl() = default;
+ SetWritebackCacheReported_Impl(SetWritebackCacheReported_Impl&& other) = default;
+ SetWritebackCacheReported_Impl& operator=(SetWritebackCacheReported_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 EnableWritebackCache = EnableWritebackCache_Impl<EnableWritebackCacheResponse>;
+ using DisableWritebackCache = DisableWritebackCache_Impl<DisableWritebackCacheResponse>;
+ using SetWritebackCacheReported = SetWritebackCacheReported_Impl<SetWritebackCacheReportedResponse>;
+ };
+
+ 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_; }
+
+ // Enables writeback caching. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // All writes will be buffered until a BLOCK_OP_FLUSH is received.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::EnableWritebackCache EnableWritebackCache();
+
+ // Enables writeback caching. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // All writes will be buffered until a BLOCK_OP_FLUSH is received.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::EnableWritebackCache EnableWritebackCache(::fidl::BytePart _response_buffer);
+
+ // Disables writeback caching. This requires the device to be disconnected at the time
+ // of the call. Calling it when the device is connected will result in undefined behavior.
+ // Disabling this cache will cause any writes to be written immediately to non-volatile storage
+ // before returning to the caller.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DisableWritebackCache DisableWritebackCache();
+
+ // Disables writeback caching. This requires the device to be disconnected at the time
+ // of the call. Calling it when the device is connected will result in undefined behavior.
+ // Disabling this cache will cause any writes to be written immediately to non-volatile storage
+ // before returning to the caller.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DisableWritebackCache DisableWritebackCache(::fidl::BytePart _response_buffer);
+
+ // Sets writeback cache reporting behavior. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // If report is set to true, the device will report its cache capability correctly to the
+ // host. If set to false, the writeback caching capabilities will NOT be reported.
+ // This can be used to test host drivers to ensure that they respond properly
+ // when the device does not report its caching capabilities.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetWritebackCacheReported SetWritebackCacheReported(bool report);
+
+ // Sets writeback cache reporting behavior. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // If report is set to true, the device will report its cache capability correctly to the
+ // host. If set to false, the writeback caching capabilities will NOT be reported.
+ // This can be used to test host drivers to ensure that they respond properly
+ // when the device does not report its caching capabilities.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetWritebackCacheReported SetWritebackCacheReported(::fidl::BytePart _request_buffer, bool report, ::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:
+
+ // Enables writeback caching. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // All writes will be buffered until a BLOCK_OP_FLUSH is received.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::EnableWritebackCache EnableWritebackCache(zx::unowned_channel _client_end);
+
+ // Enables writeback caching. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // All writes will be buffered until a BLOCK_OP_FLUSH is received.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::EnableWritebackCache EnableWritebackCache(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Disables writeback caching. This requires the device to be disconnected at the time
+ // of the call. Calling it when the device is connected will result in undefined behavior.
+ // Disabling this cache will cause any writes to be written immediately to non-volatile storage
+ // before returning to the caller.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DisableWritebackCache DisableWritebackCache(zx::unowned_channel _client_end);
+
+ // Disables writeback caching. This requires the device to be disconnected at the time
+ // of the call. Calling it when the device is connected will result in undefined behavior.
+ // Disabling this cache will cause any writes to be written immediately to non-volatile storage
+ // before returning to the caller.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DisableWritebackCache DisableWritebackCache(zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets writeback cache reporting behavior. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // If report is set to true, the device will report its cache capability correctly to the
+ // host. If set to false, the writeback caching capabilities will NOT be reported.
+ // This can be used to test host drivers to ensure that they respond properly
+ // when the device does not report its caching capabilities.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetWritebackCacheReported SetWritebackCacheReported(zx::unowned_channel _client_end, bool report);
+
+ // Sets writeback cache reporting behavior. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // If report is set to true, the device will report its cache capability correctly to the
+ // host. If set to false, the writeback caching capabilities will NOT be reported.
+ // This can be used to test host drivers to ensure that they respond properly
+ // when the device does not report its caching capabilities.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetWritebackCacheReported SetWritebackCacheReported(zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool report, ::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:
+
+ // Enables writeback caching. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // All writes will be buffered until a BLOCK_OP_FLUSH is received.
+ static ::fidl::DecodeResult<EnableWritebackCacheResponse> EnableWritebackCache(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Disables writeback caching. This requires the device to be disconnected at the time
+ // of the call. Calling it when the device is connected will result in undefined behavior.
+ // Disabling this cache will cause any writes to be written immediately to non-volatile storage
+ // before returning to the caller.
+ static ::fidl::DecodeResult<DisableWritebackCacheResponse> DisableWritebackCache(zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets writeback cache reporting behavior. This requires the device
+ // to be disconnected at the time of the call. Calling it when the device is connected
+ // will result in undefined behavior.
+ // If report is set to true, the device will report its cache capability correctly to the
+ // host. If set to false, the writeback caching capabilities will NOT be reported.
+ // This can be used to test host drivers to ensure that they respond properly
+ // when the device does not report its caching capabilities.
+ static ::fidl::DecodeResult<SetWritebackCacheReportedResponse> SetWritebackCacheReported(zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetWritebackCacheReportedRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class EnableWritebackCacheCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<EnableWritebackCacheResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using EnableWritebackCacheCompleter = ::fidl::Completer<EnableWritebackCacheCompleterBase>;
+
+ virtual void EnableWritebackCache(EnableWritebackCacheCompleter::Sync _completer) = 0;
+
+ class DisableWritebackCacheCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<DisableWritebackCacheResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DisableWritebackCacheCompleter = ::fidl::Completer<DisableWritebackCacheCompleterBase>;
+
+ virtual void DisableWritebackCache(DisableWritebackCacheCompleter::Sync _completer) = 0;
+
+ class SetWritebackCacheReportedCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetWritebackCacheReportedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetWritebackCacheReportedCompleter = ::fidl::Completer<SetWritebackCacheReportedCompleterBase>;
+
+ virtual void SetWritebackCacheReported(bool report, SetWritebackCacheReportedCompleter::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 EnableWritebackCacheRequest(const ::fidl::DecodedMessage<Device::EnableWritebackCacheRequest>& _msg);
+ static void EnableWritebackCacheResponse(const ::fidl::DecodedMessage<Device::EnableWritebackCacheResponse>& _msg);
+ static void DisableWritebackCacheRequest(const ::fidl::DecodedMessage<Device::DisableWritebackCacheRequest>& _msg);
+ static void DisableWritebackCacheResponse(const ::fidl::DecodedMessage<Device::DisableWritebackCacheResponse>& _msg);
+ static void SetWritebackCacheReportedRequest(const ::fidl::DecodedMessage<Device::SetWritebackCacheReportedRequest>& _msg);
+ static void SetWritebackCacheReportedResponse(const ::fidl::DecodedMessage<Device::SetWritebackCacheReportedResponse>& _msg);
+ };
+};
+
+} // namespace block
+} // namespace peripheral
+} // namespace usb
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::block::Device::EnableWritebackCacheResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::peripheral::block::Device::EnableWritebackCacheResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::block::Device::EnableWritebackCacheResponse)
+ == ::llcpp::fuchsia::hardware::usb::peripheral::block::Device::EnableWritebackCacheResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::block::Device::EnableWritebackCacheResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::block::Device::DisableWritebackCacheResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::peripheral::block::Device::DisableWritebackCacheResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::block::Device::DisableWritebackCacheResponse)
+ == ::llcpp::fuchsia::hardware::usb::peripheral::block::Device::DisableWritebackCacheResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::block::Device::DisableWritebackCacheResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedRequest)
+ == ::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedRequest, report) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedResponse)
+ == ::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::block::Device::SetWritebackCacheReportedResponse, status) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-usb-peripheral/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-usb-peripheral/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..00278dfd
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-usb-peripheral/gen/llcpp/fidl.cc
@@ -0,0 +1,566 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/usb/peripheral/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace usb {
+namespace peripheral {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kEvents_FunctionRegistered_Ordinal = 0x48ca785200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kEvents_FunctionRegistered_GenOrdinal = 0x191278425c4a96e8lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_EventsFunctionRegisteredRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_EventsFunctionRegisteredResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kEvents_FunctionsCleared_Ordinal = 0x24319fec00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kEvents_FunctionsCleared_GenOrdinal = 0x6feab079055dacf1lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_EventsFunctionsClearedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_EventsFunctionsClearedResponseTable;
+
+} // namespace
+template <>
+Events::ResultOf::FunctionRegistered_Impl<Events::FunctionRegisteredResponse>::FunctionRegistered_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FunctionRegisteredRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, FunctionRegisteredRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(FunctionRegisteredRequest));
+ ::fidl::DecodedMessage<FunctionRegisteredRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Events::InPlace::FunctionRegistered(std::move(_client_end), Super::response_buffer()));
+}
+
+Events::ResultOf::FunctionRegistered Events::SyncClient::FunctionRegistered() {
+ return ResultOf::FunctionRegistered(::zx::unowned_channel(this->channel_));
+}
+
+Events::ResultOf::FunctionRegistered Events::Call::FunctionRegistered(::zx::unowned_channel _client_end) {
+ return ResultOf::FunctionRegistered(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Events::FunctionRegisteredResponse> Events::InPlace::FunctionRegistered(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(FunctionRegisteredRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<FunctionRegisteredRequest> params(std::move(_request_buffer));
+ Events::SetTransactionHeaderFor::FunctionRegisteredRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Events::FunctionRegisteredResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<FunctionRegisteredRequest, FunctionRegisteredResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Events::FunctionRegisteredResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Events::ResultOf::FunctionsCleared_Impl::FunctionsCleared_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FunctionsClearedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, FunctionsClearedRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(FunctionsClearedRequest));
+ ::fidl::DecodedMessage<FunctionsClearedRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Events::InPlace::FunctionsCleared(std::move(_client_end)));
+}
+
+Events::ResultOf::FunctionsCleared Events::SyncClient::FunctionsCleared() {
+ return ResultOf::FunctionsCleared(::zx::unowned_channel(this->channel_));
+}
+
+Events::ResultOf::FunctionsCleared Events::Call::FunctionsCleared(::zx::unowned_channel _client_end) {
+ return ResultOf::FunctionsCleared(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Events::InPlace::FunctionsCleared(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(FunctionsClearedRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<FunctionsClearedRequest> params(std::move(_request_buffer));
+ Events::SetTransactionHeaderFor::FunctionsClearedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Events::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kEvents_FunctionRegistered_Ordinal:
+ case kEvents_FunctionRegistered_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<FunctionRegisteredRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->FunctionRegistered(
+ Interface::FunctionRegisteredCompleter::Sync(txn));
+ return true;
+ }
+ case kEvents_FunctionsCleared_Ordinal:
+ case kEvents_FunctionsCleared_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<FunctionsClearedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->FunctionsCleared(
+ Interface::FunctionsClearedCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Events::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Events::Interface::FunctionRegisteredCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FunctionRegisteredResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<FunctionRegisteredResponse*>(_write_bytes);
+ Events::SetTransactionHeaderFor::FunctionRegisteredResponse(
+ ::fidl::DecodedMessage<FunctionRegisteredResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ FunctionRegisteredResponse::PrimarySize,
+ FunctionRegisteredResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(FunctionRegisteredResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<FunctionRegisteredResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Events::SetTransactionHeaderFor::FunctionRegisteredRequest(const ::fidl::DecodedMessage<Events::FunctionRegisteredRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kEvents_FunctionRegistered_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Events::SetTransactionHeaderFor::FunctionRegisteredResponse(const ::fidl::DecodedMessage<Events::FunctionRegisteredResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kEvents_FunctionRegistered_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Events::SetTransactionHeaderFor::FunctionsClearedRequest(const ::fidl::DecodedMessage<Events::FunctionsClearedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kEvents_FunctionsCleared_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Device_SetConfiguration_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Device_SetConfiguration_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Device_SetConfiguration_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetConfiguration_Ordinal = 0x7969547500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetConfiguration_GenOrdinal = 0x464bafee91a3d6delu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceSetConfigurationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceSetConfigurationResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ClearFunctions_Ordinal = 0x4e0ef30000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_ClearFunctions_GenOrdinal = 0x67d9d8086dfab0cblu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceClearFunctionsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceClearFunctionsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetStateChangeListener_Ordinal = 0x4409dd700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_SetStateChangeListener_GenOrdinal = 0x5575723c4674d1d9lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceSetStateChangeListenerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceSetStateChangeListenerResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::SetConfiguration_Impl<Device::SetConfigurationResponse>::SetConfiguration_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetConfigurationRequest _request = {};
+ _request.device_desc = std::move(device_desc);
+ _request.function_descriptors = std::move(function_descriptors);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetConfigurationRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::SetConfiguration(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::SetConfiguration Device::SyncClient::SetConfiguration(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors) {
+ return ResultOf::SetConfiguration(::zx::unowned_channel(this->channel_), std::move(device_desc), std::move(function_descriptors));
+}
+
+Device::ResultOf::SetConfiguration Device::Call::SetConfiguration(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors) {
+ return ResultOf::SetConfiguration(std::move(_client_end), std::move(device_desc), std::move(function_descriptors));
+}
+
+template <>
+Device::UnownedResultOf::SetConfiguration_Impl<Device::SetConfigurationResponse>::SetConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetConfigurationRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetConfigurationResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetConfigurationRequest _request = {};
+ _request.device_desc = std::move(device_desc);
+ _request.function_descriptors = std::move(function_descriptors);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetConfigurationRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::SetConfiguration(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::SetConfiguration Device::SyncClient::SetConfiguration(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfiguration(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(device_desc), std::move(function_descriptors), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::SetConfiguration Device::Call::SetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfiguration(std::move(_client_end), std::move(_request_buffer), std::move(device_desc), std::move(function_descriptors), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::SetConfigurationResponse> Device::InPlace::SetConfiguration(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::SetConfigurationRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetConfigurationResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetConfigurationRequest, SetConfigurationResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::SetConfigurationResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::ClearFunctions_Impl<Device::ClearFunctionsResponse>::ClearFunctions_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ClearFunctionsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ClearFunctionsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ClearFunctionsRequest));
+ ::fidl::DecodedMessage<ClearFunctionsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::ClearFunctions(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::ClearFunctions Device::SyncClient::ClearFunctions() {
+ return ResultOf::ClearFunctions(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::ClearFunctions Device::Call::ClearFunctions(::zx::unowned_channel _client_end) {
+ return ResultOf::ClearFunctions(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Device::ClearFunctionsResponse> Device::InPlace::ClearFunctions(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ClearFunctionsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ClearFunctionsRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::ClearFunctionsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ClearFunctionsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ClearFunctionsRequest, ClearFunctionsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::ClearFunctionsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Device::ResultOf::SetStateChangeListener_Impl::SetStateChangeListener_Impl(::zx::unowned_channel _client_end, ::zx::channel listener) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetStateChangeListenerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetStateChangeListenerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetStateChangeListenerRequest*>(_write_bytes);
+ _request.listener = std::move(listener);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetStateChangeListenerRequest));
+ ::fidl::DecodedMessage<SetStateChangeListenerRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Device::InPlace::SetStateChangeListener(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::ResultOf::SetStateChangeListener Device::SyncClient::SetStateChangeListener(::zx::channel listener) {
+ return ResultOf::SetStateChangeListener(::zx::unowned_channel(this->channel_), std::move(listener));
+}
+
+Device::ResultOf::SetStateChangeListener Device::Call::SetStateChangeListener(::zx::unowned_channel _client_end, ::zx::channel listener) {
+ return ResultOf::SetStateChangeListener(std::move(_client_end), std::move(listener));
+}
+
+
+Device::UnownedResultOf::SetStateChangeListener_Impl::SetStateChangeListener_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel listener) {
+ if (_request_buffer.capacity() < SetStateChangeListenerRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetStateChangeListenerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetStateChangeListenerRequest*>(_request_buffer.data());
+ _request.listener = std::move(listener);
+ _request_buffer.set_actual(sizeof(SetStateChangeListenerRequest));
+ ::fidl::DecodedMessage<SetStateChangeListenerRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Device::InPlace::SetStateChangeListener(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::UnownedResultOf::SetStateChangeListener Device::SyncClient::SetStateChangeListener(::fidl::BytePart _request_buffer, ::zx::channel listener) {
+ return UnownedResultOf::SetStateChangeListener(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(listener));
+}
+
+Device::UnownedResultOf::SetStateChangeListener Device::Call::SetStateChangeListener(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel listener) {
+ return UnownedResultOf::SetStateChangeListener(std::move(_client_end), std::move(_request_buffer), std::move(listener));
+}
+
+::fidl::internal::StatusAndError Device::InPlace::SetStateChangeListener(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetStateChangeListenerRequest> params) {
+ Device::SetTransactionHeaderFor::SetStateChangeListenerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_SetConfiguration_Ordinal:
+ case kDevice_SetConfiguration_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetConfigurationRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetConfiguration(std::move(message->device_desc), std::move(message->function_descriptors),
+ Interface::SetConfigurationCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_ClearFunctions_Ordinal:
+ case kDevice_ClearFunctions_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ClearFunctionsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ClearFunctions(
+ Interface::ClearFunctionsCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_SetStateChangeListener_Ordinal:
+ case kDevice_SetStateChangeListener_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetStateChangeListenerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetStateChangeListener(std::move(message->listener),
+ Interface::SetStateChangeListenerCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::SetConfigurationCompleterBase::Reply(::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SetConfigurationResponse _response = {};
+ Device::SetTransactionHeaderFor::SetConfigurationResponse(
+ ::fidl::DecodedMessage<SetConfigurationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigurationResponse::PrimarySize,
+ SetConfigurationResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::SetConfigurationCompleterBase::ReplySuccess() {
+ Device_SetConfiguration_Response response;
+
+ Reply(Device_SetConfiguration_Result::WithResponse(&response));
+}
+void Device::Interface::SetConfigurationCompleterBase::ReplyError(int32_t error) {
+ Reply(Device_SetConfiguration_Result::WithErr(&error));
+}
+
+void Device::Interface::SetConfigurationCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Result result) {
+ if (_buffer.capacity() < SetConfigurationResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SetConfigurationResponse _response = {};
+ Device::SetTransactionHeaderFor::SetConfigurationResponse(
+ ::fidl::DecodedMessage<SetConfigurationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigurationResponse::PrimarySize,
+ SetConfigurationResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Device::Interface::SetConfigurationCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Device_SetConfiguration_Response response;
+
+ Reply(std::move(_buffer), Device_SetConfiguration_Result::WithResponse(&response));
+}
+
+void Device::Interface::SetConfigurationCompleterBase::Reply(::fidl::DecodedMessage<SetConfigurationResponse> params) {
+ Device::SetTransactionHeaderFor::SetConfigurationResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::ClearFunctionsCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ClearFunctionsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ClearFunctionsResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::ClearFunctionsResponse(
+ ::fidl::DecodedMessage<ClearFunctionsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ClearFunctionsResponse::PrimarySize,
+ ClearFunctionsResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ClearFunctionsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ClearFunctionsResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Device::SetTransactionHeaderFor::SetConfigurationRequest(const ::fidl::DecodedMessage<Device::SetConfigurationRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetConfiguration_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::SetConfigurationResponse(const ::fidl::DecodedMessage<Device::SetConfigurationResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetConfiguration_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::ClearFunctionsRequest(const ::fidl::DecodedMessage<Device::ClearFunctionsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ClearFunctions_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::ClearFunctionsResponse(const ::fidl::DecodedMessage<Device::ClearFunctionsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_ClearFunctions_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::SetStateChangeListenerRequest(const ::fidl::DecodedMessage<Device::SetStateChangeListenerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_SetStateChangeListener_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace peripheral
+} // namespace usb
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-usb-peripheral/gen/llcpp/include/fuchsia/hardware/usb/peripheral/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-usb-peripheral/gen/llcpp/include/fuchsia/hardware/usb/peripheral/llcpp/fidl.h
new file mode 100644
index 0000000..7330847
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-usb-peripheral/gen/llcpp/include/fuchsia/hardware/usb/peripheral/llcpp/fidl.h
@@ -0,0 +1,811 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace usb {
+namespace peripheral {
+
+class Events;
+struct FunctionDescriptor;
+struct Device_SetConfiguration_Response;
+struct Device_SetConfiguration_Result;
+struct DeviceDescriptor;
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_Device_SetConfiguration_ResultTable;
+
+struct Device_SetConfiguration_Result {
+ Device_SetConfiguration_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Device_SetConfiguration_Result WithResponse(::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response* val) {
+ Device_SetConfiguration_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Device_SetConfiguration_Result WithErr(int32_t* val) {
+ Device_SetConfiguration_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_peripheral_Device_SetConfiguration_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_EventsFunctionRegisteredRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_EventsFunctionRegisteredResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_EventsFunctionsClearedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_EventsFunctionsClearedResponseTable;
+// Events protocol that is used as a callback to inform the client
+// of the completion of various server-side events.
+// This callback interface can be registered using the SetStateChangeListener
+// method on the Device protocol.
+class Events final {
+ Events() = delete;
+ public:
+
+ using FunctionRegisteredResponse = ::fidl::AnyZeroArgMessage;
+ using FunctionRegisteredRequest = ::fidl::AnyZeroArgMessage;
+
+ using FunctionsClearedRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class FunctionRegistered_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ FunctionRegistered_Impl(::zx::unowned_channel _client_end);
+ ~FunctionRegistered_Impl() = default;
+ FunctionRegistered_Impl(FunctionRegistered_Impl&& other) = default;
+ FunctionRegistered_Impl& operator=(FunctionRegistered_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class FunctionsCleared_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ FunctionsCleared_Impl(::zx::unowned_channel _client_end);
+ ~FunctionsCleared_Impl() = default;
+ FunctionsCleared_Impl(FunctionsCleared_Impl&& other) = default;
+ FunctionsCleared_Impl& operator=(FunctionsCleared_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using FunctionRegistered = FunctionRegistered_Impl<FunctionRegisteredResponse>;
+ using FunctionsCleared = FunctionsCleared_Impl;
+ };
+
+ // 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 FunctionRegistered_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ FunctionRegistered_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~FunctionRegistered_Impl() = default;
+ FunctionRegistered_Impl(FunctionRegistered_Impl&& other) = default;
+ FunctionRegistered_Impl& operator=(FunctionRegistered_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class FunctionsCleared_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ FunctionsCleared_Impl(::zx::unowned_channel _client_end);
+ ~FunctionsCleared_Impl() = default;
+ FunctionsCleared_Impl(FunctionsCleared_Impl&& other) = default;
+ FunctionsCleared_Impl& operator=(FunctionsCleared_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using FunctionRegistered = FunctionRegistered_Impl<FunctionRegisteredResponse>;
+ using FunctionsCleared = FunctionsCleared_Impl;
+ };
+
+ 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_; }
+
+ // Invoked when a function registers
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::FunctionRegistered FunctionRegistered();
+
+
+ // Invoked when all functions have been cleared.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::FunctionsCleared FunctionsCleared();
+
+
+ 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:
+
+ // Invoked when a function registers
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::FunctionRegistered FunctionRegistered(::zx::unowned_channel _client_end);
+
+
+ // Invoked when all functions have been cleared.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::FunctionsCleared FunctionsCleared(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // Invoked when a function registers
+ static ::fidl::DecodeResult<FunctionRegisteredResponse> FunctionRegistered(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Invoked when all functions have been cleared.
+ static ::fidl::internal::StatusAndError FunctionsCleared(::zx::unowned_channel _client_end);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Events;
+ using _Base = ::fidl::CompleterBase;
+
+ class FunctionRegisteredCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using FunctionRegisteredCompleter = ::fidl::Completer<FunctionRegisteredCompleterBase>;
+
+ virtual void FunctionRegistered(FunctionRegisteredCompleter::Sync _completer) = 0;
+
+ using FunctionsClearedCompleter = ::fidl::Completer<>;
+
+ virtual void FunctionsCleared(FunctionsClearedCompleter::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 FunctionRegisteredRequest(const ::fidl::DecodedMessage<Events::FunctionRegisteredRequest>& _msg);
+ static void FunctionRegisteredResponse(const ::fidl::DecodedMessage<Events::FunctionRegisteredResponse>& _msg);
+ static void FunctionsClearedRequest(const ::fidl::DecodedMessage<Events::FunctionsClearedRequest>& _msg);
+ };
+};
+
+constexpr uint32_t MAX_STRING_LENGTH = 127u;
+
+constexpr uint32_t MAX_STRING_DESCRIPTORS = 255u;
+
+constexpr uint32_t MAX_FUNCTION_DESCRIPTORS = 32u;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_FunctionDescriptorTable;
+
+struct FunctionDescriptor {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_peripheral_FunctionDescriptorTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 3;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t interface_class = {};
+
+ uint8_t interface_subclass = {};
+
+ uint8_t interface_protocol = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_Device_SetConfiguration_ResponseTable;
+
+struct Device_SetConfiguration_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_peripheral_Device_SetConfiguration_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceDescriptorTable;
+
+// The fields in DeviceDescriptor match those in usb_descriptor_t in the USB specification,
+// except for the string fields.
+struct DeviceDescriptor {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_peripheral_DeviceDescriptorTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 72;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 384;
+ static constexpr bool HasPointer = true;
+
+ uint16_t bcdUSB = {};
+
+ uint8_t bDeviceClass = {};
+
+ uint8_t bDeviceSubClass = {};
+
+ uint8_t bDeviceProtocol = {};
+
+ uint8_t bMaxPacketSize0 = {};
+
+ uint16_t idVendor = {};
+
+ uint16_t idProduct = {};
+
+ uint16_t bcdDevice = {};
+
+ ::fidl::StringView manufacturer = {};
+
+ ::fidl::StringView product = {};
+
+ ::fidl::StringView serial = {};
+
+ uint8_t bNumConfigurations = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceSetConfigurationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceSetConfigurationResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceClearFunctionsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceClearFunctionsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceSetStateChangeListenerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_peripheral_DeviceSetStateChangeListenerResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct SetConfigurationResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_peripheral_DeviceSetConfigurationResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SetConfigurationRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc;
+ ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_peripheral_DeviceSetConfigurationRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 104;
+ static constexpr uint32_t MaxOutOfLine = 480;
+ static constexpr uint32_t AltPrimarySize = 104;
+ static constexpr uint32_t AltMaxOutOfLine = 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::kRequest;
+ using ResponseType = SetConfigurationResponse;
+ };
+
+ using ClearFunctionsResponse = ::fidl::AnyZeroArgMessage;
+ using ClearFunctionsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetStateChangeListenerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel listener;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_peripheral_DeviceSetStateChangeListenerRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class SetConfiguration_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetConfiguration_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors);
+ ~SetConfiguration_Impl() = default;
+ SetConfiguration_Impl(SetConfiguration_Impl&& other) = default;
+ SetConfiguration_Impl& operator=(SetConfiguration_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 ClearFunctions_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ClearFunctions_Impl(::zx::unowned_channel _client_end);
+ ~ClearFunctions_Impl() = default;
+ ClearFunctions_Impl(ClearFunctions_Impl&& other) = default;
+ ClearFunctions_Impl& operator=(ClearFunctions_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class SetStateChangeListener_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetStateChangeListener_Impl(::zx::unowned_channel _client_end, ::zx::channel listener);
+ ~SetStateChangeListener_Impl() = default;
+ SetStateChangeListener_Impl(SetStateChangeListener_Impl&& other) = default;
+ SetStateChangeListener_Impl& operator=(SetStateChangeListener_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using SetConfiguration = SetConfiguration_Impl<SetConfigurationResponse>;
+ using ClearFunctions = ClearFunctions_Impl<ClearFunctionsResponse>;
+ using SetStateChangeListener = SetStateChangeListener_Impl;
+ };
+
+ // 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 SetConfiguration_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors, ::fidl::BytePart _response_buffer);
+ ~SetConfiguration_Impl() = default;
+ SetConfiguration_Impl(SetConfiguration_Impl&& other) = default;
+ SetConfiguration_Impl& operator=(SetConfiguration_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 ClearFunctions_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ClearFunctions_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ClearFunctions_Impl() = default;
+ ClearFunctions_Impl(ClearFunctions_Impl&& other) = default;
+ ClearFunctions_Impl& operator=(ClearFunctions_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class SetStateChangeListener_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetStateChangeListener_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel listener);
+ ~SetStateChangeListener_Impl() = default;
+ SetStateChangeListener_Impl(SetStateChangeListener_Impl&& other) = default;
+ SetStateChangeListener_Impl& operator=(SetStateChangeListener_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using SetConfiguration = SetConfiguration_Impl<SetConfigurationResponse>;
+ using ClearFunctions = ClearFunctions_Impl<ClearFunctionsResponse>;
+ using SetStateChangeListener = SetStateChangeListener_Impl;
+ };
+
+ 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_; }
+
+ // Sets the device's descriptors, adds the functions and creates the child devices for the
+ // configuration's interfaces.
+ // At least one function descriptor must be provided.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SetConfiguration SetConfiguration(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors);
+
+ // Sets the device's descriptors, adds the functions and creates the child devices for the
+ // configuration's interfaces.
+ // At least one function descriptor must be provided.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetConfiguration SetConfiguration(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors, ::fidl::BytePart _response_buffer);
+
+ // Tells the device to remove the child devices for the configuration's interfaces
+ // and reset the list of functions to empty.
+ // The caller should wait for the |FunctionsCleared| event.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ClearFunctions ClearFunctions();
+
+
+ // Adds a state change listener that is invoked when a state change completes.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetStateChangeListener SetStateChangeListener(::zx::channel listener);
+
+ // Adds a state change listener that is invoked when a state change completes.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetStateChangeListener SetStateChangeListener(::fidl::BytePart _request_buffer, ::zx::channel listener);
+
+ 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:
+
+ // Sets the device's descriptors, adds the functions and creates the child devices for the
+ // configuration's interfaces.
+ // At least one function descriptor must be provided.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SetConfiguration SetConfiguration(::zx::unowned_channel _client_end, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors);
+
+ // Sets the device's descriptors, adds the functions and creates the child devices for the
+ // configuration's interfaces.
+ // At least one function descriptor must be provided.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetConfiguration SetConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors, ::fidl::BytePart _response_buffer);
+
+ // Tells the device to remove the child devices for the configuration's interfaces
+ // and reset the list of functions to empty.
+ // The caller should wait for the |FunctionsCleared| event.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ClearFunctions ClearFunctions(::zx::unowned_channel _client_end);
+
+
+ // Adds a state change listener that is invoked when a state change completes.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetStateChangeListener SetStateChangeListener(::zx::unowned_channel _client_end, ::zx::channel listener);
+
+ // Adds a state change listener that is invoked when a state change completes.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetStateChangeListener SetStateChangeListener(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel listener);
+
+ };
+
+ // 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:
+
+ // Sets the device's descriptors, adds the functions and creates the child devices for the
+ // configuration's interfaces.
+ // At least one function descriptor must be provided.
+ static ::fidl::DecodeResult<SetConfigurationResponse> SetConfiguration(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationRequest> params, ::fidl::BytePart response_buffer);
+
+ // Tells the device to remove the child devices for the configuration's interfaces
+ // and reset the list of functions to empty.
+ // The caller should wait for the |FunctionsCleared| event.
+ static ::fidl::DecodeResult<ClearFunctionsResponse> ClearFunctions(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Adds a state change listener that is invoked when a state change completes.
+ static ::fidl::internal::StatusAndError SetStateChangeListener(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetStateChangeListenerRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class SetConfigurationCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SetConfigurationResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetConfigurationCompleter = ::fidl::Completer<SetConfigurationCompleterBase>;
+
+ virtual void SetConfiguration(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor device_desc, ::fidl::VectorView<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> function_descriptors, SetConfigurationCompleter::Sync _completer) = 0;
+
+ class ClearFunctionsCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ClearFunctionsCompleter = ::fidl::Completer<ClearFunctionsCompleterBase>;
+
+ virtual void ClearFunctions(ClearFunctionsCompleter::Sync _completer) = 0;
+
+ using SetStateChangeListenerCompleter = ::fidl::Completer<>;
+
+ virtual void SetStateChangeListener(::zx::channel listener, SetStateChangeListenerCompleter::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 SetConfigurationRequest(const ::fidl::DecodedMessage<Device::SetConfigurationRequest>& _msg);
+ static void SetConfigurationResponse(const ::fidl::DecodedMessage<Device::SetConfigurationResponse>& _msg);
+ static void ClearFunctionsRequest(const ::fidl::DecodedMessage<Device::ClearFunctionsRequest>& _msg);
+ static void ClearFunctionsResponse(const ::fidl::DecodedMessage<Device::ClearFunctionsResponse>& _msg);
+ static void SetStateChangeListenerRequest(const ::fidl::DecodedMessage<Device::SetStateChangeListenerRequest>& _msg);
+ };
+};
+
+} // namespace peripheral
+} // namespace usb
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor, interface_class) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor, interface_subclass) == 1);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor, interface_protocol) == 2);
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor) == ::llcpp::fuchsia::hardware::usb::peripheral::FunctionDescriptor::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response) == ::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::usb::peripheral::Device_SetConfiguration_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor>);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, bcdUSB) == 0);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, bDeviceClass) == 2);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, bDeviceSubClass) == 3);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, bDeviceProtocol) == 4);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, bMaxPacketSize0) == 5);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, idVendor) == 6);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, idProduct) == 8);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, bcdDevice) == 10);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, manufacturer) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, product) == 32);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, serial) == 48);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor, bNumConfigurations) == 64);
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor) == ::llcpp::fuchsia::hardware::usb::peripheral::DeviceDescriptor::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationRequest)
+ == ::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationRequest, device_desc) == 16);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationRequest, function_descriptors) == 88);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationResponse)
+ == ::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::Device::SetConfigurationResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::peripheral::Device::SetStateChangeListenerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::peripheral::Device::SetStateChangeListenerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::peripheral::Device::SetStateChangeListenerRequest)
+ == ::llcpp::fuchsia::hardware::usb::peripheral::Device::SetStateChangeListenerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::peripheral::Device::SetStateChangeListenerRequest, listener) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-usb-virtual-bus/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-usb-virtual-bus/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..c1f6a00
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-usb-virtual-bus/gen/llcpp/fidl.cc
@@ -0,0 +1,550 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/usb/virtual/bus/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace usb {
+namespace virtual_ {
+namespace bus {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBus_Enable_Ordinal = 0x52804a5800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBus_Enable_GenOrdinal = 0x1849ded5bdcca327lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusEnableRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusEnableResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBus_Disable_Ordinal = 0x4962c56f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBus_Disable_GenOrdinal = 0x503b1c3fe6290c8lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusDisableRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusDisableResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBus_Connect_Ordinal = 0x6252c09800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBus_Connect_GenOrdinal = 0x1ed4d7024d941668lu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusConnectResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBus_Disconnect_Ordinal = 0x663c1cc700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBus_Disconnect_GenOrdinal = 0x78d72eefd5b46a3blu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusDisconnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusDisconnectResponseTable;
+
+} // namespace
+template <>
+Bus::ResultOf::Enable_Impl<Bus::EnableResponse>::Enable_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EnableRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, EnableRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(EnableRequest));
+ ::fidl::DecodedMessage<EnableRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Bus::InPlace::Enable(std::move(_client_end), Super::response_buffer()));
+}
+
+Bus::ResultOf::Enable Bus::SyncClient::Enable() {
+ return ResultOf::Enable(::zx::unowned_channel(this->channel_));
+}
+
+Bus::ResultOf::Enable Bus::Call::Enable(::zx::unowned_channel _client_end) {
+ return ResultOf::Enable(std::move(_client_end));
+}
+
+template <>
+Bus::UnownedResultOf::Enable_Impl<Bus::EnableResponse>::Enable_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(EnableRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, EnableRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(EnableRequest));
+ ::fidl::DecodedMessage<EnableRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Bus::InPlace::Enable(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Bus::UnownedResultOf::Enable Bus::SyncClient::Enable(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Enable(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Bus::UnownedResultOf::Enable Bus::Call::Enable(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Enable(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Bus::EnableResponse> Bus::InPlace::Enable(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(EnableRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<EnableRequest> params(std::move(_request_buffer));
+ Bus::SetTransactionHeaderFor::EnableRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Bus::EnableResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<EnableRequest, EnableResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Bus::EnableResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Bus::ResultOf::Disable_Impl<Bus::DisableResponse>::Disable_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DisableRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DisableRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DisableRequest));
+ ::fidl::DecodedMessage<DisableRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Bus::InPlace::Disable(std::move(_client_end), Super::response_buffer()));
+}
+
+Bus::ResultOf::Disable Bus::SyncClient::Disable() {
+ return ResultOf::Disable(::zx::unowned_channel(this->channel_));
+}
+
+Bus::ResultOf::Disable Bus::Call::Disable(::zx::unowned_channel _client_end) {
+ return ResultOf::Disable(std::move(_client_end));
+}
+
+template <>
+Bus::UnownedResultOf::Disable_Impl<Bus::DisableResponse>::Disable_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DisableRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DisableRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DisableRequest));
+ ::fidl::DecodedMessage<DisableRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Bus::InPlace::Disable(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Bus::UnownedResultOf::Disable Bus::SyncClient::Disable(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Disable(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Bus::UnownedResultOf::Disable Bus::Call::Disable(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Disable(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Bus::DisableResponse> Bus::InPlace::Disable(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DisableRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DisableRequest> params(std::move(_request_buffer));
+ Bus::SetTransactionHeaderFor::DisableRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Bus::DisableResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DisableRequest, DisableResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Bus::DisableResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Bus::ResultOf::Connect_Impl<Bus::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConnectRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConnectRequest));
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Bus::InPlace::Connect(std::move(_client_end), Super::response_buffer()));
+}
+
+Bus::ResultOf::Connect Bus::SyncClient::Connect() {
+ return ResultOf::Connect(::zx::unowned_channel(this->channel_));
+}
+
+Bus::ResultOf::Connect Bus::Call::Connect(::zx::unowned_channel _client_end) {
+ return ResultOf::Connect(std::move(_client_end));
+}
+
+template <>
+Bus::UnownedResultOf::Connect_Impl<Bus::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ConnectRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ConnectRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ConnectRequest));
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Bus::InPlace::Connect(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Bus::UnownedResultOf::Connect Bus::SyncClient::Connect(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Bus::UnownedResultOf::Connect Bus::Call::Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Bus::ConnectResponse> Bus::InPlace::Connect(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ConnectRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ConnectRequest> params(std::move(_request_buffer));
+ Bus::SetTransactionHeaderFor::ConnectRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Bus::ConnectResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConnectRequest, ConnectResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Bus::ConnectResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Bus::ResultOf::Disconnect_Impl<Bus::DisconnectResponse>::Disconnect_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DisconnectRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DisconnectRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DisconnectRequest));
+ ::fidl::DecodedMessage<DisconnectRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Bus::InPlace::Disconnect(std::move(_client_end), Super::response_buffer()));
+}
+
+Bus::ResultOf::Disconnect Bus::SyncClient::Disconnect() {
+ return ResultOf::Disconnect(::zx::unowned_channel(this->channel_));
+}
+
+Bus::ResultOf::Disconnect Bus::Call::Disconnect(::zx::unowned_channel _client_end) {
+ return ResultOf::Disconnect(std::move(_client_end));
+}
+
+template <>
+Bus::UnownedResultOf::Disconnect_Impl<Bus::DisconnectResponse>::Disconnect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DisconnectRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DisconnectRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DisconnectRequest));
+ ::fidl::DecodedMessage<DisconnectRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Bus::InPlace::Disconnect(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Bus::UnownedResultOf::Disconnect Bus::SyncClient::Disconnect(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Disconnect(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Bus::UnownedResultOf::Disconnect Bus::Call::Disconnect(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Disconnect(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Bus::DisconnectResponse> Bus::InPlace::Disconnect(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DisconnectRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DisconnectRequest> params(std::move(_request_buffer));
+ Bus::SetTransactionHeaderFor::DisconnectRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Bus::DisconnectResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DisconnectRequest, DisconnectResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Bus::DisconnectResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Bus::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBus_Enable_Ordinal:
+ case kBus_Enable_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EnableRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Enable(
+ Interface::EnableCompleter::Sync(txn));
+ return true;
+ }
+ case kBus_Disable_Ordinal:
+ case kBus_Disable_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DisableRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Disable(
+ Interface::DisableCompleter::Sync(txn));
+ return true;
+ }
+ case kBus_Connect_Ordinal:
+ case kBus_Connect_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConnectRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Connect(
+ Interface::ConnectCompleter::Sync(txn));
+ return true;
+ }
+ case kBus_Disconnect_Ordinal:
+ case kBus_Disconnect_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DisconnectRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Disconnect(
+ Interface::DisconnectCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Bus::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Bus::Interface::EnableCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EnableResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<EnableResponse*>(_write_bytes);
+ Bus::SetTransactionHeaderFor::EnableResponse(
+ ::fidl::DecodedMessage<EnableResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EnableResponse::PrimarySize,
+ EnableResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(EnableResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EnableResponse>(std::move(_response_bytes)));
+}
+
+void Bus::Interface::EnableCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < EnableResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<EnableResponse*>(_buffer.data());
+ Bus::SetTransactionHeaderFor::EnableResponse(
+ ::fidl::DecodedMessage<EnableResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EnableResponse::PrimarySize,
+ EnableResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(EnableResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EnableResponse>(std::move(_buffer)));
+}
+
+void Bus::Interface::EnableCompleterBase::Reply(::fidl::DecodedMessage<EnableResponse> params) {
+ Bus::SetTransactionHeaderFor::EnableResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Bus::Interface::DisableCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DisableResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DisableResponse*>(_write_bytes);
+ Bus::SetTransactionHeaderFor::DisableResponse(
+ ::fidl::DecodedMessage<DisableResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DisableResponse::PrimarySize,
+ DisableResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DisableResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DisableResponse>(std::move(_response_bytes)));
+}
+
+void Bus::Interface::DisableCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < DisableResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DisableResponse*>(_buffer.data());
+ Bus::SetTransactionHeaderFor::DisableResponse(
+ ::fidl::DecodedMessage<DisableResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DisableResponse::PrimarySize,
+ DisableResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(DisableResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DisableResponse>(std::move(_buffer)));
+}
+
+void Bus::Interface::DisableCompleterBase::Reply(::fidl::DecodedMessage<DisableResponse> params) {
+ Bus::SetTransactionHeaderFor::DisableResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Bus::Interface::ConnectCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConnectResponse*>(_write_bytes);
+ Bus::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConnectResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConnectResponse>(std::move(_response_bytes)));
+}
+
+void Bus::Interface::ConnectCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ConnectResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConnectResponse*>(_buffer.data());
+ Bus::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ConnectResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConnectResponse>(std::move(_buffer)));
+}
+
+void Bus::Interface::ConnectCompleterBase::Reply(::fidl::DecodedMessage<ConnectResponse> params) {
+ Bus::SetTransactionHeaderFor::ConnectResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Bus::Interface::DisconnectCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DisconnectResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DisconnectResponse*>(_write_bytes);
+ Bus::SetTransactionHeaderFor::DisconnectResponse(
+ ::fidl::DecodedMessage<DisconnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DisconnectResponse::PrimarySize,
+ DisconnectResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DisconnectResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DisconnectResponse>(std::move(_response_bytes)));
+}
+
+void Bus::Interface::DisconnectCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < DisconnectResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<DisconnectResponse*>(_buffer.data());
+ Bus::SetTransactionHeaderFor::DisconnectResponse(
+ ::fidl::DecodedMessage<DisconnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DisconnectResponse::PrimarySize,
+ DisconnectResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(DisconnectResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DisconnectResponse>(std::move(_buffer)));
+}
+
+void Bus::Interface::DisconnectCompleterBase::Reply(::fidl::DecodedMessage<DisconnectResponse> params) {
+ Bus::SetTransactionHeaderFor::DisconnectResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Bus::SetTransactionHeaderFor::EnableRequest(const ::fidl::DecodedMessage<Bus::EnableRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBus_Enable_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Bus::SetTransactionHeaderFor::EnableResponse(const ::fidl::DecodedMessage<Bus::EnableResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBus_Enable_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Bus::SetTransactionHeaderFor::DisableRequest(const ::fidl::DecodedMessage<Bus::DisableRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBus_Disable_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Bus::SetTransactionHeaderFor::DisableResponse(const ::fidl::DecodedMessage<Bus::DisableResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBus_Disable_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Bus::SetTransactionHeaderFor::ConnectRequest(const ::fidl::DecodedMessage<Bus::ConnectRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBus_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Bus::SetTransactionHeaderFor::ConnectResponse(const ::fidl::DecodedMessage<Bus::ConnectResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBus_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Bus::SetTransactionHeaderFor::DisconnectRequest(const ::fidl::DecodedMessage<Bus::DisconnectRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBus_Disconnect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Bus::SetTransactionHeaderFor::DisconnectResponse(const ::fidl::DecodedMessage<Bus::DisconnectResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBus_Disconnect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace bus
+} // namespace virtual_
+} // namespace usb
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-usb-virtual-bus/gen/llcpp/include/fuchsia/hardware/usb/virtual/bus/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-usb-virtual-bus/gen/llcpp/include/fuchsia/hardware/usb/virtual/bus/llcpp/fidl.h
new file mode 100644
index 0000000..259fcee
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-usb-virtual-bus/gen/llcpp/include/fuchsia/hardware/usb/virtual/bus/llcpp/fidl.h
@@ -0,0 +1,512 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace usb {
+namespace virtual_ {
+namespace bus {
+
+class Bus;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusEnableRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusEnableResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusDisableRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusDisableResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusConnectResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusDisconnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_usb_virtual_bus_BusDisconnectResponseTable;
+
+class Bus final {
+ Bus() = delete;
+ public:
+
+ struct EnableResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_virtual_bus_BusEnableResponseTable;
+ 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 EnableRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DisableResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_virtual_bus_BusDisableResponseTable;
+ 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 DisableRequest = ::fidl::AnyZeroArgMessage;
+
+ struct ConnectResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_virtual_bus_BusConnectResponseTable;
+ 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 ConnectRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DisconnectResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_usb_virtual_bus_BusDisconnectResponseTable;
+ 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 DisconnectRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Enable_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Enable_Impl(::zx::unowned_channel _client_end);
+ ~Enable_Impl() = default;
+ Enable_Impl(Enable_Impl&& other) = default;
+ Enable_Impl& operator=(Enable_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 Disable_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Disable_Impl(::zx::unowned_channel _client_end);
+ ~Disable_Impl() = default;
+ Disable_Impl(Disable_Impl&& other) = default;
+ Disable_Impl& operator=(Disable_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 Connect_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 Disconnect_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Disconnect_Impl(::zx::unowned_channel _client_end);
+ ~Disconnect_Impl() = default;
+ Disconnect_Impl(Disconnect_Impl&& other) = default;
+ Disconnect_Impl& operator=(Disconnect_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 Enable = Enable_Impl<EnableResponse>;
+ using Disable = Disable_Impl<DisableResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using Disconnect = Disconnect_Impl<DisconnectResponse>;
+ };
+
+ // 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 Enable_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Enable_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Enable_Impl() = default;
+ Enable_Impl(Enable_Impl&& other) = default;
+ Enable_Impl& operator=(Enable_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 Disable_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Disable_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Disable_Impl() = default;
+ Disable_Impl(Disable_Impl&& other) = default;
+ Disable_Impl& operator=(Disable_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 Connect_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 Disconnect_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Disconnect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Disconnect_Impl() = default;
+ Disconnect_Impl(Disconnect_Impl&& other) = default;
+ Disconnect_Impl& operator=(Disconnect_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 Enable = Enable_Impl<EnableResponse>;
+ using Disable = Disable_Impl<DisableResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using Disconnect = Disconnect_Impl<DisconnectResponse>;
+ };
+
+ 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_; }
+
+ // Enables the virtual bus.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Enable Enable();
+
+ // Enables the virtual bus.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Enable Enable(::fidl::BytePart _response_buffer);
+
+ // Disables the virtual bus.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Disable Disable();
+
+ // Disables the virtual bus.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Disable Disable(::fidl::BytePart _response_buffer);
+
+ // Simulates a USB connected event.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Connect Connect();
+
+ // Simulates a USB connected event.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Connect Connect(::fidl::BytePart _response_buffer);
+
+ // Simulates a USB connected event.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Disconnect Disconnect();
+
+ // Simulates a USB connected event.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Disconnect Disconnect(::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:
+
+ // Enables the virtual bus.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Enable Enable(::zx::unowned_channel _client_end);
+
+ // Enables the virtual bus.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Enable Enable(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Disables the virtual bus.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Disable Disable(::zx::unowned_channel _client_end);
+
+ // Disables the virtual bus.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Disable Disable(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Simulates a USB connected event.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Connect Connect(::zx::unowned_channel _client_end);
+
+ // Simulates a USB connected event.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Simulates a USB connected event.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Disconnect Disconnect(::zx::unowned_channel _client_end);
+
+ // Simulates a USB connected event.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Disconnect Disconnect(::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:
+
+ // Enables the virtual bus.
+ static ::fidl::DecodeResult<EnableResponse> Enable(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Disables the virtual bus.
+ static ::fidl::DecodeResult<DisableResponse> Disable(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Simulates a USB connected event.
+ static ::fidl::DecodeResult<ConnectResponse> Connect(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Simulates a USB connected event.
+ static ::fidl::DecodeResult<DisconnectResponse> Disconnect(::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 = Bus;
+ using _Base = ::fidl::CompleterBase;
+
+ class EnableCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<EnableResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using EnableCompleter = ::fidl::Completer<EnableCompleterBase>;
+
+ virtual void Enable(EnableCompleter::Sync _completer) = 0;
+
+ class DisableCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<DisableResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DisableCompleter = ::fidl::Completer<DisableCompleterBase>;
+
+ virtual void Disable(DisableCompleter::Sync _completer) = 0;
+
+ class ConnectCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ConnectResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConnectCompleter = ::fidl::Completer<ConnectCompleterBase>;
+
+ virtual void Connect(ConnectCompleter::Sync _completer) = 0;
+
+ class DisconnectCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<DisconnectResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DisconnectCompleter = ::fidl::Completer<DisconnectCompleterBase>;
+
+ virtual void Disconnect(DisconnectCompleter::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 EnableRequest(const ::fidl::DecodedMessage<Bus::EnableRequest>& _msg);
+ static void EnableResponse(const ::fidl::DecodedMessage<Bus::EnableResponse>& _msg);
+ static void DisableRequest(const ::fidl::DecodedMessage<Bus::DisableRequest>& _msg);
+ static void DisableResponse(const ::fidl::DecodedMessage<Bus::DisableResponse>& _msg);
+ static void ConnectRequest(const ::fidl::DecodedMessage<Bus::ConnectRequest>& _msg);
+ static void ConnectResponse(const ::fidl::DecodedMessage<Bus::ConnectResponse>& _msg);
+ static void DisconnectRequest(const ::fidl::DecodedMessage<Bus::DisconnectRequest>& _msg);
+ static void DisconnectResponse(const ::fidl::DecodedMessage<Bus::DisconnectResponse>& _msg);
+ };
+};
+
+} // namespace bus
+} // namespace virtual_
+} // namespace usb
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::EnableResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::EnableResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::EnableResponse)
+ == ::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::EnableResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::EnableResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisableResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisableResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisableResponse)
+ == ::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisableResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisableResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::ConnectResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::ConnectResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::ConnectResponse)
+ == ::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::ConnectResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::ConnectResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisconnectResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisconnectResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisconnectResponse)
+ == ::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisconnectResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::usb::virtual_::bus::Bus::DisconnectResponse, status) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-hardware-virtioconsole/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-hardware-virtioconsole/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..8919c09
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-virtioconsole/gen/llcpp/fidl.cc
@@ -0,0 +1,137 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/hardware/virtioconsole/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace virtioconsole {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetChannel_Ordinal = 0x1ff7011500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetChannel_GenOrdinal = 0x2add7b2741b2d65dlu;
+extern "C" const fidl_type_t v1_fuchsia_hardware_virtioconsole_DeviceGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_virtioconsole_DeviceGetChannelResponseTable;
+
+} // namespace
+
+Device::ResultOf::GetChannel_Impl::GetChannel_Impl(::zx::unowned_channel _client_end, ::zx::channel req) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetChannelRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetChannelRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetChannelRequest*>(_write_bytes);
+ _request.req = std::move(req);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Device::InPlace::GetChannel(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::ResultOf::GetChannel Device::SyncClient::GetChannel(::zx::channel req) {
+ return ResultOf::GetChannel(::zx::unowned_channel(this->channel_), std::move(req));
+}
+
+Device::ResultOf::GetChannel Device::Call::GetChannel(::zx::unowned_channel _client_end, ::zx::channel req) {
+ return ResultOf::GetChannel(std::move(_client_end), std::move(req));
+}
+
+
+Device::UnownedResultOf::GetChannel_Impl::GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel req) {
+ if (_request_buffer.capacity() < GetChannelRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetChannelRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetChannelRequest*>(_request_buffer.data());
+ _request.req = std::move(req);
+ _request_buffer.set_actual(sizeof(GetChannelRequest));
+ ::fidl::DecodedMessage<GetChannelRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Device::InPlace::GetChannel(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Device::UnownedResultOf::GetChannel Device::SyncClient::GetChannel(::fidl::BytePart _request_buffer, ::zx::channel req) {
+ return UnownedResultOf::GetChannel(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(req));
+}
+
+Device::UnownedResultOf::GetChannel Device::Call::GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel req) {
+ return UnownedResultOf::GetChannel(std::move(_client_end), std::move(_request_buffer), std::move(req));
+}
+
+::fidl::internal::StatusAndError Device::InPlace::GetChannel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetChannelRequest> params) {
+ Device::SetTransactionHeaderFor::GetChannelRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetChannel_Ordinal:
+ case kDevice_GetChannel_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetChannelRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetChannel(std::move(message->req),
+ Interface::GetChannelCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetChannelRequest(const ::fidl::DecodedMessage<Device::GetChannelRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetChannel_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace virtioconsole
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-hardware-virtioconsole/gen/llcpp/include/fuchsia/hardware/virtioconsole/llcpp/fidl.h b/zircon/system/fidl/fuchsia-hardware-virtioconsole/gen/llcpp/include/fuchsia/hardware/virtioconsole/llcpp/fidl.h
new file mode 100644
index 0000000..2edc554
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-hardware-virtioconsole/gen/llcpp/include/fuchsia/hardware/virtioconsole/llcpp/fidl.h
@@ -0,0 +1,222 @@
+// 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 <zircon/fidl.h>
+
+#include <fuchsia/hardware/pty/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace hardware {
+namespace virtioconsole {
+
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_hardware_virtioconsole_DeviceGetChannelRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_hardware_virtioconsole_DeviceGetChannelResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+
+ struct GetChannelRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel req;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_hardware_virtioconsole_DeviceGetChannelRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class GetChannel_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end, ::zx::channel req);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using GetChannel = GetChannel_Impl;
+ };
+
+ // 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:
+ class GetChannel_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ GetChannel_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel req);
+ ~GetChannel_Impl() = default;
+ GetChannel_Impl(GetChannel_Impl&& other) = default;
+ GetChannel_Impl& operator=(GetChannel_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using GetChannel = GetChannel_Impl;
+ };
+
+ 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_; }
+
+ // This API is temporary. It exists because devhost multiplexes
+ // fuchsia.io.File on top of the device connections, and
+ // fuchsia.hardware.pty.Device composes with that interface. Once
+ // the devhost stops the behavior, we can remove this interface and
+ // have virtio-console just serve fuchsia.hardware.pty.Device directly.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetChannel GetChannel(::zx::channel req);
+
+ // This API is temporary. It exists because devhost multiplexes
+ // fuchsia.io.File on top of the device connections, and
+ // fuchsia.hardware.pty.Device composes with that interface. Once
+ // the devhost stops the behavior, we can remove this interface and
+ // have virtio-console just serve fuchsia.hardware.pty.Device directly.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetChannel GetChannel(::fidl::BytePart _request_buffer, ::zx::channel req);
+
+ 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:
+
+ // This API is temporary. It exists because devhost multiplexes
+ // fuchsia.io.File on top of the device connections, and
+ // fuchsia.hardware.pty.Device composes with that interface. Once
+ // the devhost stops the behavior, we can remove this interface and
+ // have virtio-console just serve fuchsia.hardware.pty.Device directly.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetChannel GetChannel(::zx::unowned_channel _client_end, ::zx::channel req);
+
+ // This API is temporary. It exists because devhost multiplexes
+ // fuchsia.io.File on top of the device connections, and
+ // fuchsia.hardware.pty.Device composes with that interface. Once
+ // the devhost stops the behavior, we can remove this interface and
+ // have virtio-console just serve fuchsia.hardware.pty.Device directly.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetChannel GetChannel(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel req);
+
+ };
+
+ // 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:
+
+ // This API is temporary. It exists because devhost multiplexes
+ // fuchsia.io.File on top of the device connections, and
+ // fuchsia.hardware.pty.Device composes with that interface. Once
+ // the devhost stops the behavior, we can remove this interface and
+ // have virtio-console just serve fuchsia.hardware.pty.Device directly.
+ static ::fidl::internal::StatusAndError GetChannel(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetChannelRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ using GetChannelCompleter = ::fidl::Completer<>;
+
+ virtual void GetChannel(::zx::channel req, GetChannelCompleter::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 GetChannelRequest(const ::fidl::DecodedMessage<Device::GetChannelRequest>& _msg);
+ };
+};
+
+} // namespace virtioconsole
+} // namespace hardware
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::hardware::virtioconsole::Device::GetChannelRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::hardware::virtioconsole::Device::GetChannelRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::hardware::virtioconsole::Device::GetChannelRequest)
+ == ::llcpp::fuchsia::hardware::virtioconsole::Device::GetChannelRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::hardware::virtioconsole::Device::GetChannelRequest, req) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-io/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-io/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..0789883
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-io/gen/llcpp/fidl.cc
@@ -0,0 +1,8733 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/io/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace io {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDirectoryWatcher_OnEvent_Ordinal = 0x208bcc9d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryWatcher_OnEvent_GenOrdinal = 0x3937a088fe53412alu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatcherOnEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatcherOnEventResponseTable;
+
+} // namespace
+
+DirectoryWatcher::ResultOf::OnEvent_Impl::OnEvent_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> events) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnEventRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ OnEventRequest _request = {};
+ _request.events = std::move(events);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OnEventRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DirectoryWatcher::InPlace::OnEvent(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DirectoryWatcher::ResultOf::OnEvent DirectoryWatcher::SyncClient::OnEvent(::fidl::VectorView<uint8_t> events) {
+ return ResultOf::OnEvent(::zx::unowned_channel(this->channel_), std::move(events));
+}
+
+DirectoryWatcher::ResultOf::OnEvent DirectoryWatcher::Call::OnEvent(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> events) {
+ return ResultOf::OnEvent(std::move(_client_end), std::move(events));
+}
+
+
+DirectoryWatcher::UnownedResultOf::OnEvent_Impl::OnEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events) {
+ if (_request_buffer.capacity() < OnEventRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ OnEventRequest _request = {};
+ _request.events = std::move(events);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OnEventRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DirectoryWatcher::InPlace::OnEvent(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DirectoryWatcher::UnownedResultOf::OnEvent DirectoryWatcher::SyncClient::OnEvent(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events) {
+ return UnownedResultOf::OnEvent(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(events));
+}
+
+DirectoryWatcher::UnownedResultOf::OnEvent DirectoryWatcher::Call::OnEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events) {
+ return UnownedResultOf::OnEvent(std::move(_client_end), std::move(_request_buffer), std::move(events));
+}
+
+::fidl::internal::StatusAndError DirectoryWatcher::InPlace::OnEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnEventRequest> params) {
+ DirectoryWatcher::SetTransactionHeaderFor::OnEventRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool DirectoryWatcher::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDirectoryWatcher_OnEvent_Ordinal:
+ case kDirectoryWatcher_OnEvent_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnEventRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OnEvent(std::move(message->events),
+ Interface::OnEventCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DirectoryWatcher::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void DirectoryWatcher::SetTransactionHeaderFor::OnEventRequest(const ::fidl::DecodedMessage<DirectoryWatcher::OnEventRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryWatcher_OnEvent_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::io::NodeInfo::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(NodeInfo) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(NodeInfo, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(NodeInfo, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kNode_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeSetFlagsResponseTable;
+
+} // namespace
+
+Node::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Node::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Node::ResultOf::Clone Node::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+Node::ResultOf::Clone Node::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+Node::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Node::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Node::UnownedResultOf::Clone Node::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+Node::UnownedResultOf::Clone Node::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError Node::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ Node::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Node::ResultOf::Close_Impl<Node::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+Node::ResultOf::Close Node::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Node::ResultOf::Close Node::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+Node::UnownedResultOf::Close_Impl<Node::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::Close Node::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::Close Node::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::CloseResponse> Node::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Node::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::Describe_Impl<Node::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+Node::ResultOf::Describe Node::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+Node::ResultOf::Describe Node::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+Node::UnownedResultOf::Describe_Impl<Node::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::Describe Node::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::Describe Node::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::DescribeResponse> Node::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ Node::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::Sync_Impl<Node::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Node::ResultOf::Sync Node::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Node::ResultOf::Sync Node::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Node::UnownedResultOf::Sync_Impl<Node::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::Sync Node::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::Sync Node::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::SyncResponse> Node::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Node::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::GetAttr_Impl<Node::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+Node::ResultOf::GetAttr Node::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+Node::ResultOf::GetAttr Node::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+Node::UnownedResultOf::GetAttr_Impl<Node::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::GetAttr Node::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::GetAttr Node::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::GetAttrResponse> Node::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ Node::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::SetAttr_Impl<Node::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Node::ResultOf::SetAttr Node::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+Node::ResultOf::SetAttr Node::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+Node::UnownedResultOf::SetAttr_Impl<Node::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::SetAttr Node::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::SetAttr Node::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::SetAttrResponse> Node::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ Node::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::NodeGetFlags_Impl<Node::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+Node::ResultOf::NodeGetFlags Node::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+Node::ResultOf::NodeGetFlags Node::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+Node::UnownedResultOf::NodeGetFlags_Impl<Node::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::NodeGetFlags Node::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::NodeGetFlags Node::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::NodeGetFlagsResponse> Node::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ Node::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::NodeSetFlags_Impl<Node::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Node::ResultOf::NodeSetFlags Node::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Node::ResultOf::NodeSetFlags Node::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Node::UnownedResultOf::NodeSetFlags_Impl<Node::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::NodeSetFlags Node::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::NodeSetFlags Node::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::NodeSetFlagsResponse> Node::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ Node::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Node::SyncClient::HandleEvents(Node::EventHandlers handlers) {
+ return Node::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Node::Call::HandleEvents(::zx::unowned_channel client_end, Node::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kNode_OnOpen_Ordinal:
+ case kNode_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Node::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kNode_Clone_Ordinal:
+ case kNode_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_Close_Ordinal:
+ case kNode_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_Describe_Ordinal:
+ case kNode_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_Sync_Ordinal:
+ case kNode_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_GetAttr_Ordinal:
+ case kNode_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_SetAttr_Ordinal:
+ case kNode_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_NodeGetFlags_Ordinal:
+ case kNode_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_NodeSetFlags_Ordinal:
+ case kNode_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Node::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Node::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ Node::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ Node::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ Node::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ Node::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Node::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Node::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Node::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Node::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Node::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ Node::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Node::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ Node::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Node::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ Node::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Node::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ Node::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ Node::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Node::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ Node::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ Node::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ Node::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ Node::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ Node::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ Node::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ Node::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ Node::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ Node::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ Node::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Node::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ Node::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void Node::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ Node::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Node::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<Node::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Node::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<Node::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Node::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Node::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<Node::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Node::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Node::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<Node::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<Node::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<Node::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<Node::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<Node::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<Node::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<Node::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<Node::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kFile_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Read_Ordinal = 0x25f7418400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Read_GenOrdinal = 0x29b2b7074c95208clu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileReadResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_ReadAt_Ordinal = 0x7c724dc400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_ReadAt_GenOrdinal = 0x6527ee3fbc9c5749lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileReadAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileReadAtResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Write_Ordinal = 0x512e7a000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Write_GenOrdinal = 0x3b6432f57914225blu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileWriteResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_WriteAt_Ordinal = 0x3e5522e500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_WriteAt_GenOrdinal = 0x4b29e1582ab379e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileWriteAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileWriteAtResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Seek_Ordinal = 0x782a774500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Seek_GenOrdinal = 0x324968e9b8a0e394lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSeekRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSeekResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Truncate_Ordinal = 0x42ab3a3a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Truncate_GenOrdinal = 0x5ec8f337359a2ddblu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileTruncateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileTruncateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetFlags_Ordinal = 0x6416a3f600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetFlags_GenOrdinal = 0x200be82ca523ab96lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_SetFlags_Ordinal = 0x3f23cc7600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_SetFlags_GenOrdinal = 0x713f375258671141lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetBuffer_Ordinal = 0x74c3097300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetBuffer_GenOrdinal = 0x4b93b8486666d951lu;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetBufferResponseTable;
+
+} // namespace
+
+File::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ File::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+File::ResultOf::Clone File::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+File::ResultOf::Clone File::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+File::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ File::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+File::UnownedResultOf::Clone File::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+File::UnownedResultOf::Clone File::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError File::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ File::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+File::ResultOf::Close_Impl<File::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+File::ResultOf::Close File::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::Close File::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+File::UnownedResultOf::Close_Impl<File::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Close File::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Close File::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::CloseResponse> File::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Describe_Impl<File::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+File::ResultOf::Describe File::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::Describe File::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+File::UnownedResultOf::Describe_Impl<File::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Describe File::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Describe File::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::DescribeResponse> File::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Sync_Impl<File::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+File::ResultOf::Sync File::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::Sync File::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+File::UnownedResultOf::Sync_Impl<File::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Sync File::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Sync File::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::SyncResponse> File::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::GetAttr_Impl<File::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+File::ResultOf::GetAttr File::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::GetAttr File::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+File::UnownedResultOf::GetAttr_Impl<File::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::GetAttr File::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::GetAttr File::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::GetAttrResponse> File::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::SetAttr_Impl<File::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::SetAttr File::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+File::ResultOf::SetAttr File::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+File::UnownedResultOf::SetAttr_Impl<File::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::SetAttr File::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::SetAttr File::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::SetAttrResponse> File::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::NodeGetFlags_Impl<File::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+File::ResultOf::NodeGetFlags File::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::NodeGetFlags File::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+File::UnownedResultOf::NodeGetFlags_Impl<File::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::NodeGetFlags File::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::NodeGetFlags File::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::NodeGetFlagsResponse> File::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::NodeSetFlags_Impl<File::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::NodeSetFlags File::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+File::ResultOf::NodeSetFlags File::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+File::UnownedResultOf::NodeSetFlags_Impl<File::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::NodeSetFlags File::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::NodeSetFlags File::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::NodeSetFlagsResponse> File::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Read_Impl<File::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, uint64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_write_bytes);
+ _request.count = std::move(count);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Read(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Read File::SyncClient::Read(uint64_t count) {
+ return ResultOf::Read(::zx::unowned_channel(this->channel_), std::move(count));
+}
+
+File::ResultOf::Read File::Call::Read(::zx::unowned_channel _client_end, uint64_t count) {
+ return ResultOf::Read(std::move(_client_end), std::move(count));
+}
+
+template <>
+File::UnownedResultOf::Read_Impl<File::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_request_buffer.data());
+ _request.count = std::move(count);
+ _request_buffer.set_actual(sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Read(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Read File::SyncClient::Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Read File::Call::Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(std::move(_client_end), std::move(_request_buffer), std::move(count), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::ReadResponse> File::InPlace::Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::ReadRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ReadResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadRequest, ReadResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ReadResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::ReadAt_Impl<File::ReadAtResponse>::ReadAt_Impl(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAtRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadAtRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAtRequest*>(_write_bytes);
+ _request.count = std::move(count);
+ _request.offset = std::move(offset);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadAtRequest));
+ ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::ReadAt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::ReadAt File::SyncClient::ReadAt(uint64_t count, uint64_t offset) {
+ return ResultOf::ReadAt(::zx::unowned_channel(this->channel_), std::move(count), std::move(offset));
+}
+
+File::ResultOf::ReadAt File::Call::ReadAt(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset) {
+ return ResultOf::ReadAt(std::move(_client_end), std::move(count), std::move(offset));
+}
+
+template <>
+File::UnownedResultOf::ReadAt_Impl<File::ReadAtResponse>::ReadAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadAtRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadAtResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadAtRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAtRequest*>(_request_buffer.data());
+ _request.count = std::move(count);
+ _request.offset = std::move(offset);
+ _request_buffer.set_actual(sizeof(ReadAtRequest));
+ ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::ReadAt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::ReadAt File::SyncClient::ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::ReadAt File::Call::ReadAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAt(std::move(_client_end), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::ReadAtResponse> File::InPlace::ReadAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::ReadAtRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ReadAtResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadAtRequest, ReadAtResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ReadAtResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Write_Impl<File::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::Write(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Write File::SyncClient::Write(::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Write(::zx::unowned_channel(this->channel_), std::move(data));
+}
+
+File::ResultOf::Write File::Call::Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Write(std::move(_client_end), std::move(data));
+}
+
+template <>
+File::UnownedResultOf::Write_Impl<File::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::Write(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Write File::SyncClient::Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Write File::Call::Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::WriteResponse> File::InPlace::Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::WriteRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::WriteResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::WriteResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::WriteAt_Impl<File::WriteAtResponse>::WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteAtRequest _request = {};
+ _request.data = std::move(data);
+ _request.offset = std::move(offset);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::WriteAt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::WriteAt File::SyncClient::WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ return ResultOf::WriteAt(::zx::unowned_channel(this->channel_), std::move(data), std::move(offset));
+}
+
+File::ResultOf::WriteAt File::Call::WriteAt(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ return ResultOf::WriteAt(std::move(_client_end), std::move(data), std::move(offset));
+}
+
+template <>
+File::UnownedResultOf::WriteAt_Impl<File::WriteAtResponse>::WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteAtRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteAtResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteAtRequest _request = {};
+ _request.data = std::move(data);
+ _request.offset = std::move(offset);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::WriteAt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::WriteAt File::SyncClient::WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::WriteAt File::Call::WriteAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAt(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::WriteAtResponse> File::InPlace::WriteAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::WriteAtRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::WriteAtResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteAtRequest, WriteAtResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::WriteAtResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Seek_Impl<File::SeekResponse>::Seek_Impl(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SeekRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SeekRequest*>(_write_bytes);
+ _request.offset = std::move(offset);
+ _request.start = std::move(start);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SeekRequest));
+ ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Seek(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Seek File::SyncClient::Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
+ return ResultOf::Seek(::zx::unowned_channel(this->channel_), std::move(offset), std::move(start));
+}
+
+File::ResultOf::Seek File::Call::Seek(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start) {
+ return ResultOf::Seek(std::move(_client_end), std::move(offset), std::move(start));
+}
+
+template <>
+File::UnownedResultOf::Seek_Impl<File::SeekResponse>::Seek_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SeekRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SeekResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SeekRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SeekRequest*>(_request_buffer.data());
+ _request.offset = std::move(offset);
+ _request.start = std::move(start);
+ _request_buffer.set_actual(sizeof(SeekRequest));
+ ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Seek(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Seek File::SyncClient::Seek(::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Seek(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(offset), std::move(start), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Seek File::Call::Seek(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Seek(std::move(_client_end), std::move(_request_buffer), std::move(offset), std::move(start), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::SeekResponse> File::InPlace::Seek(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::SeekRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SeekResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SeekRequest, SeekResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SeekResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Truncate_Impl<File::TruncateResponse>::Truncate_Impl(::zx::unowned_channel _client_end, uint64_t length) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TruncateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, TruncateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<TruncateRequest*>(_write_bytes);
+ _request.length = std::move(length);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(TruncateRequest));
+ ::fidl::DecodedMessage<TruncateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Truncate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Truncate File::SyncClient::Truncate(uint64_t length) {
+ return ResultOf::Truncate(::zx::unowned_channel(this->channel_), std::move(length));
+}
+
+File::ResultOf::Truncate File::Call::Truncate(::zx::unowned_channel _client_end, uint64_t length) {
+ return ResultOf::Truncate(std::move(_client_end), std::move(length));
+}
+
+template <>
+File::UnownedResultOf::Truncate_Impl<File::TruncateResponse>::Truncate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < TruncateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<TruncateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, TruncateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<TruncateRequest*>(_request_buffer.data());
+ _request.length = std::move(length);
+ _request_buffer.set_actual(sizeof(TruncateRequest));
+ ::fidl::DecodedMessage<TruncateRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Truncate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Truncate File::SyncClient::Truncate(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Truncate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(length), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Truncate File::Call::Truncate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Truncate(std::move(_client_end), std::move(_request_buffer), std::move(length), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::TruncateResponse> File::InPlace::Truncate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TruncateRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::TruncateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::TruncateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<TruncateRequest, TruncateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::TruncateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::GetFlags_Impl<File::GetFlagsResponse>::GetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFlagsRequest));
+ ::fidl::DecodedMessage<GetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::GetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+File::ResultOf::GetFlags File::SyncClient::GetFlags() {
+ return ResultOf::GetFlags(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::GetFlags File::Call::GetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::GetFlags(std::move(_client_end));
+}
+
+template <>
+File::UnownedResultOf::GetFlags_Impl<File::GetFlagsResponse>::GetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetFlagsRequest));
+ ::fidl::DecodedMessage<GetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::GetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::GetFlags File::SyncClient::GetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::GetFlags File::Call::GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::GetFlagsResponse> File::InPlace::GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetFlagsRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::GetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetFlagsRequest, GetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::SetFlags_Impl<File::SetFlagsResponse>::SetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetFlagsRequest));
+ ::fidl::DecodedMessage<SetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::SetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::SetFlags File::SyncClient::SetFlags(uint32_t flags) {
+ return ResultOf::SetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+File::ResultOf::SetFlags File::Call::SetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::SetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+File::UnownedResultOf::SetFlags_Impl<File::SetFlagsResponse>::SetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(SetFlagsRequest));
+ ::fidl::DecodedMessage<SetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::SetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::SetFlags File::SyncClient::SetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::SetFlags File::Call::SetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::SetFlagsResponse> File::InPlace::SetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::SetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetFlagsRequest, SetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::GetBuffer_Impl<File::GetBufferResponse>::GetBuffer_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBufferRequest));
+ ::fidl::DecodedMessage<GetBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::GetBuffer(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::GetBuffer File::SyncClient::GetBuffer(uint32_t flags) {
+ return ResultOf::GetBuffer(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+File::ResultOf::GetBuffer File::Call::GetBuffer(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::GetBuffer(std::move(_client_end), std::move(flags));
+}
+
+template <>
+File::UnownedResultOf::GetBuffer_Impl<File::GetBufferResponse>::GetBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetBufferRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetBufferResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(GetBufferRequest));
+ ::fidl::DecodedMessage<GetBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::GetBuffer(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::GetBuffer File::SyncClient::GetBuffer(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::GetBuffer File::Call::GetBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBuffer(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::GetBufferResponse> File::InPlace::GetBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::GetBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetBufferResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetBufferRequest, GetBufferResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetBufferResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t File::SyncClient::HandleEvents(File::EventHandlers handlers) {
+ return File::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t File::Call::HandleEvents(::zx::unowned_channel client_end, File::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kFile_OnOpen_Ordinal:
+ case kFile_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool File::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kFile_Clone_Ordinal:
+ case kFile_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Close_Ordinal:
+ case kFile_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Describe_Ordinal:
+ case kFile_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Sync_Ordinal:
+ case kFile_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_GetAttr_Ordinal:
+ case kFile_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_SetAttr_Ordinal:
+ case kFile_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_NodeGetFlags_Ordinal:
+ case kFile_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_NodeSetFlags_Ordinal:
+ case kFile_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Read_Ordinal:
+ case kFile_Read_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Read(std::move(message->count),
+ Interface::ReadCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_ReadAt_Ordinal:
+ case kFile_ReadAt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadAtRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReadAt(std::move(message->count), std::move(message->offset),
+ Interface::ReadAtCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Write_Ordinal:
+ case kFile_Write_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Write(std::move(message->data),
+ Interface::WriteCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_WriteAt_Ordinal:
+ case kFile_WriteAt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteAtRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteAt(std::move(message->data), std::move(message->offset),
+ Interface::WriteAtCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Seek_Ordinal:
+ case kFile_Seek_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SeekRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Seek(std::move(message->offset), std::move(message->start),
+ Interface::SeekCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Truncate_Ordinal:
+ case kFile_Truncate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<TruncateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Truncate(std::move(message->length),
+ Interface::TruncateCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_GetFlags_Ordinal:
+ case kFile_GetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetFlags(
+ Interface::GetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_SetFlags_Ordinal:
+ case kFile_SetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetFlags(std::move(message->flags),
+ Interface::SetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_GetBuffer_Ordinal:
+ case kFile_GetBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetBuffer(std::move(message->flags),
+ Interface::GetBufferCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool File::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void File::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void File::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ File::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ File::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ File::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ File::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t File::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ File::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t File::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ File::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t File::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ File::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void File::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void File::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ File::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void File::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ File::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void File::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ File::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void File::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ File::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void File::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ File::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::ReadCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadResponse _response = {};
+ File::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::ReadCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data) {
+ if (_buffer.capacity() < ReadResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadResponse _response = {};
+ File::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::ReadCompleterBase::Reply(::fidl::DecodedMessage<ReadResponse> params) {
+ File::SetTransactionHeaderFor::ReadResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::ReadAtCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAtResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadAtResponse _response = {};
+ File::SetTransactionHeaderFor::ReadAtResponse(
+ ::fidl::DecodedMessage<ReadAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAtResponse::PrimarySize,
+ ReadAtResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::ReadAtCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data) {
+ if (_buffer.capacity() < ReadAtResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadAtResponse _response = {};
+ File::SetTransactionHeaderFor::ReadAtResponse(
+ ::fidl::DecodedMessage<ReadAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAtResponse::PrimarySize,
+ ReadAtResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::ReadAtCompleterBase::Reply(::fidl::DecodedMessage<ReadAtResponse> params) {
+ File::SetTransactionHeaderFor::ReadAtResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::WriteCompleterBase::Reply(int32_t s, uint64_t actual) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.actual = std::move(actual);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::WriteCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual) {
+ if (_buffer.capacity() < WriteResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.actual = std::move(actual);
+ _buffer.set_actual(sizeof(WriteResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteResponse>(std::move(_buffer)));
+}
+
+void File::Interface::WriteCompleterBase::Reply(::fidl::DecodedMessage<WriteResponse> params) {
+ File::SetTransactionHeaderFor::WriteResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::WriteAtCompleterBase::Reply(int32_t s, uint64_t actual) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteAtResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::WriteAtResponse(
+ ::fidl::DecodedMessage<WriteAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAtResponse::PrimarySize,
+ WriteAtResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.actual = std::move(actual);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteAtResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteAtResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::WriteAtCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual) {
+ if (_buffer.capacity() < WriteAtResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteAtResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::WriteAtResponse(
+ ::fidl::DecodedMessage<WriteAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAtResponse::PrimarySize,
+ WriteAtResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.actual = std::move(actual);
+ _buffer.set_actual(sizeof(WriteAtResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteAtResponse>(std::move(_buffer)));
+}
+
+void File::Interface::WriteAtCompleterBase::Reply(::fidl::DecodedMessage<WriteAtResponse> params) {
+ File::SetTransactionHeaderFor::WriteAtResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::SeekCompleterBase::Reply(int32_t s, uint64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SeekResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::SeekResponse(
+ ::fidl::DecodedMessage<SeekResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SeekResponse::PrimarySize,
+ SeekResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.offset = std::move(offset);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SeekResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SeekResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::SeekCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t offset) {
+ if (_buffer.capacity() < SeekResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SeekResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::SeekResponse(
+ ::fidl::DecodedMessage<SeekResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SeekResponse::PrimarySize,
+ SeekResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.offset = std::move(offset);
+ _buffer.set_actual(sizeof(SeekResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SeekResponse>(std::move(_buffer)));
+}
+
+void File::Interface::SeekCompleterBase::Reply(::fidl::DecodedMessage<SeekResponse> params) {
+ File::SetTransactionHeaderFor::SeekResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::TruncateCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TruncateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<TruncateResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::TruncateResponse(
+ ::fidl::DecodedMessage<TruncateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TruncateResponse::PrimarySize,
+ TruncateResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(TruncateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<TruncateResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::TruncateCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < TruncateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<TruncateResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::TruncateResponse(
+ ::fidl::DecodedMessage<TruncateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TruncateResponse::PrimarySize,
+ TruncateResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(TruncateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<TruncateResponse>(std::move(_buffer)));
+}
+
+void File::Interface::TruncateCompleterBase::Reply(::fidl::DecodedMessage<TruncateResponse> params) {
+ File::SetTransactionHeaderFor::TruncateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::GetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetFlagsResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::GetFlagsResponse(
+ ::fidl::DecodedMessage<GetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFlagsResponse::PrimarySize,
+ GetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::GetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < GetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetFlagsResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::GetFlagsResponse(
+ ::fidl::DecodedMessage<GetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetFlagsResponse::PrimarySize,
+ GetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(GetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetFlagsResponse>(std::move(_buffer)));
+}
+
+void File::Interface::GetFlagsCompleterBase::Reply(::fidl::DecodedMessage<GetFlagsResponse> params) {
+ File::SetTransactionHeaderFor::GetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::SetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetFlagsResponse*>(_write_bytes);
+ File::SetTransactionHeaderFor::SetFlagsResponse(
+ ::fidl::DecodedMessage<SetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetFlagsResponse::PrimarySize,
+ SetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void File::Interface::SetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetFlagsResponse*>(_buffer.data());
+ File::SetTransactionHeaderFor::SetFlagsResponse(
+ ::fidl::DecodedMessage<SetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetFlagsResponse::PrimarySize,
+ SetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetFlagsResponse>(std::move(_buffer)));
+}
+
+void File::Interface::SetFlagsCompleterBase::Reply(::fidl::DecodedMessage<SetFlagsResponse> params) {
+ File::SetTransactionHeaderFor::SetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::GetBufferCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetBufferResponse _response = {};
+ File::SetTransactionHeaderFor::GetBufferResponse(
+ ::fidl::DecodedMessage<GetBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferResponse::PrimarySize,
+ GetBufferResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.buffer = std::move(buffer);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::GetBufferCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer) {
+ if (_buffer.capacity() < GetBufferResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetBufferResponse _response = {};
+ File::SetTransactionHeaderFor::GetBufferResponse(
+ ::fidl::DecodedMessage<GetBufferResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferResponse::PrimarySize,
+ GetBufferResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.buffer = std::move(buffer);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::GetBufferCompleterBase::Reply(::fidl::DecodedMessage<GetBufferResponse> params) {
+ File::SetTransactionHeaderFor::GetBufferResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void File::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<File::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<File::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<File::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<File::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<File::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<File::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<File::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<File::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<File::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<File::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<File::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<File::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<File::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<File::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<File::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<File::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::ReadRequest(const ::fidl::DecodedMessage<File::ReadRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::ReadResponse(const ::fidl::DecodedMessage<File::ReadResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::ReadAtRequest(const ::fidl::DecodedMessage<File::ReadAtRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_ReadAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::ReadAtResponse(const ::fidl::DecodedMessage<File::ReadAtResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_ReadAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::WriteRequest(const ::fidl::DecodedMessage<File::WriteRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::WriteResponse(const ::fidl::DecodedMessage<File::WriteResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::WriteAtRequest(const ::fidl::DecodedMessage<File::WriteAtRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_WriteAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::WriteAtResponse(const ::fidl::DecodedMessage<File::WriteAtResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_WriteAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::SeekRequest(const ::fidl::DecodedMessage<File::SeekRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Seek_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::SeekResponse(const ::fidl::DecodedMessage<File::SeekResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Seek_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::TruncateRequest(const ::fidl::DecodedMessage<File::TruncateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Truncate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::TruncateResponse(const ::fidl::DecodedMessage<File::TruncateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Truncate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::GetFlagsRequest(const ::fidl::DecodedMessage<File::GetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::GetFlagsResponse(const ::fidl::DecodedMessage<File::GetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::SetFlagsRequest(const ::fidl::DecodedMessage<File::SetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_SetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::SetFlagsResponse(const ::fidl::DecodedMessage<File::SetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_SetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::GetBufferRequest(const ::fidl::DecodedMessage<File::GetBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::GetBufferResponse(const ::fidl::DecodedMessage<File::GetBufferResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectorySyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectorySyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectorySetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectorySetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Open_Ordinal = 0x77e4cceb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Open_GenOrdinal = 0x2c5044561d685ec0lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOpenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Unlink_Ordinal = 0x2cbadb1900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Unlink_GenOrdinal = 0x5a0ff90760a8bc23lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryUnlinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryUnlinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_ReadDirents_Ordinal = 0x2ea53c2d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_ReadDirents_GenOrdinal = 0x3582806bf27faa0alu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryReadDirentsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryReadDirentsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Rewind_Ordinal = 0x7072fd8700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Rewind_GenOrdinal = 0x16b1202af0f34c71lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRewindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRewindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_GetToken_Ordinal = 0x3217bced00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_GetToken_GenOrdinal = 0x26ae9d18763c8655lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Rename_Ordinal = 0x4a94b0ac00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Rename_GenOrdinal = 0xa8e00a247f3c905lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRenameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRenameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Link_Ordinal = 0x1b8a5e6400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Link_GenOrdinal = 0x740604c0c7c930e7lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryLinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryLinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Watch_Ordinal = 0x5ac28f3400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Watch_GenOrdinal = 0x5717193a59d66d91lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatchResponseTable;
+
+} // namespace
+
+Directory::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Directory::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::ResultOf::Clone Directory::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+Directory::ResultOf::Clone Directory::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+Directory::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Directory::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::UnownedResultOf::Clone Directory::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+Directory::UnownedResultOf::Clone Directory::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError Directory::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ Directory::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Directory::ResultOf::Close_Impl<Directory::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::Close Directory::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::Close Directory::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::Close_Impl<Directory::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Close Directory::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Close Directory::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::CloseResponse> Directory::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::Describe_Impl<Directory::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::Describe Directory::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::Describe Directory::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::Describe_Impl<Directory::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Describe Directory::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Describe Directory::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::DescribeResponse> Directory::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::Sync_Impl<Directory::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::Sync Directory::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::Sync Directory::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::Sync_Impl<Directory::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Sync Directory::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Sync Directory::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::SyncResponse> Directory::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::GetAttr_Impl<Directory::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::GetAttr Directory::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::GetAttr Directory::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::GetAttr_Impl<Directory::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::GetAttr Directory::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::GetAttr Directory::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::GetAttrResponse> Directory::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::SetAttr_Impl<Directory::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::SetAttr Directory::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+Directory::ResultOf::SetAttr Directory::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+Directory::UnownedResultOf::SetAttr_Impl<Directory::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::SetAttr Directory::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::SetAttr Directory::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::SetAttrResponse> Directory::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::NodeGetFlags_Impl<Directory::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::NodeGetFlags Directory::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::NodeGetFlags Directory::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::NodeGetFlags_Impl<Directory::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::NodeGetFlags Directory::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::NodeGetFlags Directory::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::NodeGetFlagsResponse> Directory::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::NodeSetFlags_Impl<Directory::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::NodeSetFlags Directory::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Directory::ResultOf::NodeSetFlags Directory::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Directory::UnownedResultOf::NodeSetFlags_Impl<Directory::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::NodeSetFlags Directory::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::NodeSetFlags Directory::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::NodeSetFlagsResponse> Directory::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Directory::ResultOf::Open_Impl::Open_Impl(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ OpenRequest _request = {};
+ _request.flags = std::move(flags);
+ _request.mode = std::move(mode);
+ _request.path = std::move(path);
+ _request.object = std::move(object);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Open(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::ResultOf::Open Directory::SyncClient::Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return ResultOf::Open(::zx::unowned_channel(this->channel_), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+Directory::ResultOf::Open Directory::Call::Open(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return ResultOf::Open(std::move(_client_end), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+
+Directory::UnownedResultOf::Open_Impl::Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ if (_request_buffer.capacity() < OpenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ OpenRequest _request = {};
+ _request.flags = std::move(flags);
+ _request.mode = std::move(mode);
+ _request.path = std::move(path);
+ _request.object = std::move(object);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Open(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::UnownedResultOf::Open Directory::SyncClient::Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return UnownedResultOf::Open(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+Directory::UnownedResultOf::Open Directory::Call::Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return UnownedResultOf::Open(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+::fidl::internal::StatusAndError Directory::InPlace::Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params) {
+ Directory::SetTransactionHeaderFor::OpenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Directory::ResultOf::Unlink_Impl<Directory::UnlinkResponse>::Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ UnlinkRequest _request = {};
+ _request.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Unlink(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::Unlink Directory::SyncClient::Unlink(::fidl::StringView path) {
+ return ResultOf::Unlink(::zx::unowned_channel(this->channel_), std::move(path));
+}
+
+Directory::ResultOf::Unlink Directory::Call::Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path) {
+ return ResultOf::Unlink(std::move(_client_end), std::move(path));
+}
+
+template <>
+Directory::UnownedResultOf::Unlink_Impl<Directory::UnlinkResponse>::Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UnlinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UnlinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UnlinkRequest _request = {};
+ _request.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Unlink(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Unlink Directory::SyncClient::Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unlink(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(path), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Unlink Directory::Call::Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unlink(std::move(_client_end), std::move(_request_buffer), std::move(path), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::UnlinkResponse> Directory::InPlace::Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::UnlinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::UnlinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::UnlinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::ReadDirents_Impl<Directory::ReadDirentsResponse>::ReadDirents_Impl(::zx::unowned_channel _client_end, uint64_t max_bytes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirentsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadDirentsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadDirentsRequest*>(_write_bytes);
+ _request.max_bytes = std::move(max_bytes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadDirentsRequest));
+ ::fidl::DecodedMessage<ReadDirentsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::ReadDirents(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::ReadDirents Directory::SyncClient::ReadDirents(uint64_t max_bytes) {
+ return ResultOf::ReadDirents(::zx::unowned_channel(this->channel_), std::move(max_bytes));
+}
+
+Directory::ResultOf::ReadDirents Directory::Call::ReadDirents(::zx::unowned_channel _client_end, uint64_t max_bytes) {
+ return ResultOf::ReadDirents(std::move(_client_end), std::move(max_bytes));
+}
+
+template <>
+Directory::UnownedResultOf::ReadDirents_Impl<Directory::ReadDirentsResponse>::ReadDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadDirentsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadDirentsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadDirentsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadDirentsRequest*>(_request_buffer.data());
+ _request.max_bytes = std::move(max_bytes);
+ _request_buffer.set_actual(sizeof(ReadDirentsRequest));
+ ::fidl::DecodedMessage<ReadDirentsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::ReadDirents(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::ReadDirents Directory::SyncClient::ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadDirents(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(max_bytes), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::ReadDirents Directory::Call::ReadDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadDirents(std::move(_client_end), std::move(_request_buffer), std::move(max_bytes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::ReadDirentsResponse> Directory::InPlace::ReadDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::ReadDirentsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::ReadDirentsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadDirentsRequest, ReadDirentsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::ReadDirentsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::Rewind_Impl<Directory::RewindResponse>::Rewind_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RewindRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindRequest));
+ ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::Rewind(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::Rewind Directory::SyncClient::Rewind() {
+ return ResultOf::Rewind(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::Rewind Directory::Call::Rewind(::zx::unowned_channel _client_end) {
+ return ResultOf::Rewind(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::Rewind_Impl<Directory::RewindResponse>::Rewind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RewindRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, RewindRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(RewindRequest));
+ ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::Rewind(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Rewind Directory::SyncClient::Rewind(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rewind(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Rewind Directory::Call::Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rewind(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::RewindResponse> Directory::InPlace::Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(RewindRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<RewindRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::RewindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::RewindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::RewindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::GetToken_Impl<Directory::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::GetToken Directory::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::GetToken Directory::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::GetToken_Impl<Directory::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::GetToken Directory::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::GetToken Directory::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::GetTokenResponse> Directory::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::Rename_Impl<Directory::RenameResponse>::Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ RenameRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Rename(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::Rename Directory::SyncClient::Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Rename(::zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+Directory::ResultOf::Rename Directory::Call::Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Rename(std::move(_client_end), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+template <>
+Directory::UnownedResultOf::Rename_Impl<Directory::RenameResponse>::Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RenameRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RenameResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ RenameRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Rename(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Rename Directory::SyncClient::Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rename(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Rename Directory::Call::Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rename(std::move(_client_end), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::RenameResponse> Directory::InPlace::Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::RenameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::RenameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::RenameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::Link_Impl<Directory::LinkResponse>::Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LinkRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Link(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::Link Directory::SyncClient::Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Link(::zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+Directory::ResultOf::Link Directory::Call::Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Link(std::move(_client_end), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+template <>
+Directory::UnownedResultOf::Link_Impl<Directory::LinkResponse>::Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LinkRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Link(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Link Directory::SyncClient::Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Link(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Link Directory::Call::Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Link(std::move(_client_end), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::LinkResponse> Directory::InPlace::Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::LinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::LinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::LinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::Watch_Impl<Directory::WatchResponse>::Watch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WatchRequest*>(_write_bytes);
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchRequest));
+ ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::Watch(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::Watch Directory::SyncClient::Watch(uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ return ResultOf::Watch(::zx::unowned_channel(this->channel_), std::move(mask), std::move(options), std::move(watcher));
+}
+
+Directory::ResultOf::Watch Directory::Call::Watch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ return ResultOf::Watch(std::move(_client_end), std::move(mask), std::move(options), std::move(watcher));
+}
+
+template <>
+Directory::UnownedResultOf::Watch_Impl<Directory::WatchResponse>::Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WatchRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WatchResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WatchRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WatchRequest*>(_request_buffer.data());
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ _request_buffer.set_actual(sizeof(WatchRequest));
+ ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::Watch(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Watch Directory::SyncClient::Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Watch(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Watch Directory::Call::Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Watch(std::move(_client_end), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::WatchResponse> Directory::InPlace::Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::WatchRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::WatchResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::WatchResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Directory::SyncClient::HandleEvents(Directory::EventHandlers handlers) {
+ return Directory::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Directory::Call::HandleEvents(::zx::unowned_channel client_end, Directory::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kDirectory_OnOpen_Ordinal:
+ case kDirectory_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Directory::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDirectory_Clone_Ordinal:
+ case kDirectory_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Close_Ordinal:
+ case kDirectory_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Describe_Ordinal:
+ case kDirectory_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Sync_Ordinal:
+ case kDirectory_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_GetAttr_Ordinal:
+ case kDirectory_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_SetAttr_Ordinal:
+ case kDirectory_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_NodeGetFlags_Ordinal:
+ case kDirectory_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_NodeSetFlags_Ordinal:
+ case kDirectory_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Open_Ordinal:
+ case kDirectory_Open_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Open(std::move(message->flags), std::move(message->mode), std::move(message->path), std::move(message->object),
+ Interface::OpenCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Unlink_Ordinal:
+ case kDirectory_Unlink_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnlinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Unlink(std::move(message->path),
+ Interface::UnlinkCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_ReadDirents_Ordinal:
+ case kDirectory_ReadDirents_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadDirentsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReadDirents(std::move(message->max_bytes),
+ Interface::ReadDirentsCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Rewind_Ordinal:
+ case kDirectory_Rewind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RewindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Rewind(
+ Interface::RewindCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_GetToken_Ordinal:
+ case kDirectory_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Rename_Ordinal:
+ case kDirectory_Rename_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RenameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Rename(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+ Interface::RenameCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Link_Ordinal:
+ case kDirectory_Link_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Link(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+ Interface::LinkCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Watch_Ordinal:
+ case kDirectory_Watch_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Watch(std::move(message->mask), std::move(message->options), std::move(message->watcher),
+ Interface::WatchCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Directory::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Directory::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ Directory::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ Directory::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Directory::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Directory::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Directory::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ Directory::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Directory::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ Directory::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Directory::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ Directory::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Directory::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Directory::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ Directory::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ Directory::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ Directory::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ Directory::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::UnlinkCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<UnlinkResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::UnlinkResponse(
+ ::fidl::DecodedMessage<UnlinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnlinkResponse::PrimarySize,
+ UnlinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnlinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::UnlinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < UnlinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<UnlinkResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::UnlinkResponse(
+ ::fidl::DecodedMessage<UnlinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnlinkResponse::PrimarySize,
+ UnlinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(UnlinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::UnlinkCompleterBase::Reply(::fidl::DecodedMessage<UnlinkResponse> params) {
+ Directory::SetTransactionHeaderFor::UnlinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::ReadDirentsCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirentsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadDirentsResponse _response = {};
+ Directory::SetTransactionHeaderFor::ReadDirentsResponse(
+ ::fidl::DecodedMessage<ReadDirentsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDirentsResponse::PrimarySize,
+ ReadDirentsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::ReadDirentsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+ if (_buffer.capacity() < ReadDirentsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadDirentsResponse _response = {};
+ Directory::SetTransactionHeaderFor::ReadDirentsResponse(
+ ::fidl::DecodedMessage<ReadDirentsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDirentsResponse::PrimarySize,
+ ReadDirentsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::ReadDirentsCompleterBase::Reply(::fidl::DecodedMessage<ReadDirentsResponse> params) {
+ Directory::SetTransactionHeaderFor::ReadDirentsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::RewindCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RewindResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::RewindResponse(
+ ::fidl::DecodedMessage<RewindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RewindResponse::PrimarySize,
+ RewindResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::RewindCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < RewindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RewindResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::RewindResponse(
+ ::fidl::DecodedMessage<RewindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RewindResponse::PrimarySize,
+ RewindResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(RewindResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::RewindCompleterBase::Reply(::fidl::DecodedMessage<RewindResponse> params) {
+ Directory::SetTransactionHeaderFor::RewindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::GetTokenCompleterBase::Reply(int32_t s, ::zx::handle token) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetTokenResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.token = std::move(token);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetTokenResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.token = std::move(token);
+ _buffer.set_actual(sizeof(GetTokenResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ Directory::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::RenameCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RenameResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::RenameResponse(
+ ::fidl::DecodedMessage<RenameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RenameResponse::PrimarySize,
+ RenameResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RenameResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::RenameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < RenameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RenameResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::RenameResponse(
+ ::fidl::DecodedMessage<RenameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RenameResponse::PrimarySize,
+ RenameResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(RenameResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::RenameCompleterBase::Reply(::fidl::DecodedMessage<RenameResponse> params) {
+ Directory::SetTransactionHeaderFor::RenameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::LinkCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LinkResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::LinkResponse(
+ ::fidl::DecodedMessage<LinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LinkResponse::PrimarySize,
+ LinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::LinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < LinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LinkResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::LinkResponse(
+ ::fidl::DecodedMessage<LinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LinkResponse::PrimarySize,
+ LinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(LinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::LinkCompleterBase::Reply(::fidl::DecodedMessage<LinkResponse> params) {
+ Directory::SetTransactionHeaderFor::LinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::WatchCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WatchResponse*>(_write_bytes);
+ Directory::SetTransactionHeaderFor::WatchResponse(
+ ::fidl::DecodedMessage<WatchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchResponse::PrimarySize,
+ WatchResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_response_bytes)));
+}
+
+void Directory::Interface::WatchCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < WatchResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WatchResponse*>(_buffer.data());
+ Directory::SetTransactionHeaderFor::WatchResponse(
+ ::fidl::DecodedMessage<WatchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchResponse::PrimarySize,
+ WatchResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(WatchResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_buffer)));
+}
+
+void Directory::Interface::WatchCompleterBase::Reply(::fidl::DecodedMessage<WatchResponse> params) {
+ Directory::SetTransactionHeaderFor::WatchResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Directory::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<Directory::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Directory::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<Directory::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Directory::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Directory::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<Directory::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Directory::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Directory::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<Directory::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<Directory::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<Directory::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<Directory::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<Directory::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<Directory::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<Directory::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<Directory::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::OpenRequest(const ::fidl::DecodedMessage<Directory::OpenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Open_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::UnlinkRequest(const ::fidl::DecodedMessage<Directory::UnlinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Unlink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::UnlinkResponse(const ::fidl::DecodedMessage<Directory::UnlinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Unlink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::ReadDirentsRequest(const ::fidl::DecodedMessage<Directory::ReadDirentsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_ReadDirents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::ReadDirentsResponse(const ::fidl::DecodedMessage<Directory::ReadDirentsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_ReadDirents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::RewindRequest(const ::fidl::DecodedMessage<Directory::RewindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Rewind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::RewindResponse(const ::fidl::DecodedMessage<Directory::RewindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Rewind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<Directory::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<Directory::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::RenameRequest(const ::fidl::DecodedMessage<Directory::RenameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Rename_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::RenameResponse(const ::fidl::DecodedMessage<Directory::RenameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Rename_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::LinkRequest(const ::fidl::DecodedMessage<Directory::LinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Link_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::LinkResponse(const ::fidl::DecodedMessage<Directory::LinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Link_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::WatchRequest(const ::fidl::DecodedMessage<Directory::WatchRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Watch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::WatchResponse(const ::fidl::DecodedMessage<Directory::WatchResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Watch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Open_Ordinal = 0x77e4cceb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Open_GenOrdinal = 0x2c5044561d685ec0lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOpenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Unlink_Ordinal = 0x2cbadb1900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Unlink_GenOrdinal = 0x5a0ff90760a8bc23lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnlinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnlinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_ReadDirents_Ordinal = 0x2ea53c2d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_ReadDirents_GenOrdinal = 0x3582806bf27faa0alu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminReadDirentsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminReadDirentsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Rewind_Ordinal = 0x7072fd8700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Rewind_GenOrdinal = 0x16b1202af0f34c71lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRewindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRewindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_GetToken_Ordinal = 0x3217bced00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_GetToken_GenOrdinal = 0x26ae9d18763c8655lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Rename_Ordinal = 0x4a94b0ac00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Rename_GenOrdinal = 0xa8e00a247f3c905lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRenameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRenameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Link_Ordinal = 0x1b8a5e6400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Link_GenOrdinal = 0x740604c0c7c930e7lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminLinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminLinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Watch_Ordinal = 0x5ac28f3400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Watch_GenOrdinal = 0x5717193a59d66d91lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminWatchResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Mount_Ordinal = 0x7e5f12e600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Mount_GenOrdinal = 0xfa166d1522c27d0lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_MountAndCreate_Ordinal = 0x3225f69100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_MountAndCreate_GenOrdinal = 0x7bc782242022b3b3lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountAndCreateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountAndCreateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Unmount_Ordinal = 0x2502275400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_Unmount_GenOrdinal = 0x7da45d654c35c9a4lu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_UnmountNode_Ordinal = 0x16da38a700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_UnmountNode_GenOrdinal = 0x26b9d90ebe5f93dblu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountNodeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountNodeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_QueryFilesystem_Ordinal = 0x66298d9200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_QueryFilesystem_GenOrdinal = 0x4a879480f1d7875dlu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminQueryFilesystemRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminQueryFilesystemResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_GetDevicePath_Ordinal = 0x2ef70eb800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryAdmin_GetDevicePath_GenOrdinal = 0x76f2e3c7331f815blu;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetDevicePathRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetDevicePathResponseTable;
+
+} // namespace
+
+DirectoryAdmin::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DirectoryAdmin::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DirectoryAdmin::ResultOf::Clone DirectoryAdmin::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+DirectoryAdmin::ResultOf::Clone DirectoryAdmin::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+DirectoryAdmin::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DirectoryAdmin::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DirectoryAdmin::UnownedResultOf::Clone DirectoryAdmin::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+DirectoryAdmin::UnownedResultOf::Clone DirectoryAdmin::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError DirectoryAdmin::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+DirectoryAdmin::ResultOf::Close_Impl<DirectoryAdmin::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Close DirectoryAdmin::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::Close DirectoryAdmin::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Close_Impl<DirectoryAdmin::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Close DirectoryAdmin::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Close DirectoryAdmin::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::CloseResponse> DirectoryAdmin::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::Describe_Impl<DirectoryAdmin::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Describe DirectoryAdmin::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::Describe DirectoryAdmin::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Describe_Impl<DirectoryAdmin::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Describe DirectoryAdmin::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Describe DirectoryAdmin::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::DescribeResponse> DirectoryAdmin::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::Sync_Impl<DirectoryAdmin::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Sync DirectoryAdmin::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::Sync DirectoryAdmin::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Sync_Impl<DirectoryAdmin::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Sync DirectoryAdmin::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Sync DirectoryAdmin::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::SyncResponse> DirectoryAdmin::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::GetAttr_Impl<DirectoryAdmin::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::GetAttr DirectoryAdmin::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::GetAttr DirectoryAdmin::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::GetAttr_Impl<DirectoryAdmin::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::GetAttr DirectoryAdmin::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::GetAttr DirectoryAdmin::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetAttrResponse> DirectoryAdmin::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::SetAttr_Impl<DirectoryAdmin::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::SetAttr DirectoryAdmin::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+DirectoryAdmin::ResultOf::SetAttr DirectoryAdmin::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::SetAttr_Impl<DirectoryAdmin::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::SetAttr DirectoryAdmin::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::SetAttr DirectoryAdmin::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::SetAttrResponse> DirectoryAdmin::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::NodeGetFlags_Impl<DirectoryAdmin::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::NodeGetFlags DirectoryAdmin::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::NodeGetFlags DirectoryAdmin::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::NodeGetFlags_Impl<DirectoryAdmin::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::NodeGetFlags DirectoryAdmin::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::NodeGetFlags DirectoryAdmin::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::NodeGetFlagsResponse> DirectoryAdmin::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::NodeSetFlags_Impl<DirectoryAdmin::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::NodeSetFlags DirectoryAdmin::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+DirectoryAdmin::ResultOf::NodeSetFlags DirectoryAdmin::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::NodeSetFlags_Impl<DirectoryAdmin::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::NodeSetFlags DirectoryAdmin::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::NodeSetFlags DirectoryAdmin::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::NodeSetFlagsResponse> DirectoryAdmin::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+DirectoryAdmin::ResultOf::Open_Impl::Open_Impl(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ OpenRequest _request = {};
+ _request.flags = std::move(flags);
+ _request.mode = std::move(mode);
+ _request.path = std::move(path);
+ _request.object = std::move(object);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DirectoryAdmin::InPlace::Open(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DirectoryAdmin::ResultOf::Open DirectoryAdmin::SyncClient::Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return ResultOf::Open(::zx::unowned_channel(this->channel_), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+DirectoryAdmin::ResultOf::Open DirectoryAdmin::Call::Open(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return ResultOf::Open(std::move(_client_end), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+
+DirectoryAdmin::UnownedResultOf::Open_Impl::Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ if (_request_buffer.capacity() < OpenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ OpenRequest _request = {};
+ _request.flags = std::move(flags);
+ _request.mode = std::move(mode);
+ _request.path = std::move(path);
+ _request.object = std::move(object);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DirectoryAdmin::InPlace::Open(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DirectoryAdmin::UnownedResultOf::Open DirectoryAdmin::SyncClient::Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return UnownedResultOf::Open(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+DirectoryAdmin::UnownedResultOf::Open DirectoryAdmin::Call::Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object) {
+ return UnownedResultOf::Open(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(mode), std::move(path), std::move(object));
+}
+
+::fidl::internal::StatusAndError DirectoryAdmin::InPlace::Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::OpenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+DirectoryAdmin::ResultOf::Unlink_Impl<DirectoryAdmin::UnlinkResponse>::Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ UnlinkRequest _request = {};
+ _request.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Unlink(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Unlink DirectoryAdmin::SyncClient::Unlink(::fidl::StringView path) {
+ return ResultOf::Unlink(::zx::unowned_channel(this->channel_), std::move(path));
+}
+
+DirectoryAdmin::ResultOf::Unlink DirectoryAdmin::Call::Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path) {
+ return ResultOf::Unlink(std::move(_client_end), std::move(path));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Unlink_Impl<DirectoryAdmin::UnlinkResponse>::Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UnlinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UnlinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UnlinkRequest _request = {};
+ _request.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Unlink(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Unlink DirectoryAdmin::SyncClient::Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unlink(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(path), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Unlink DirectoryAdmin::Call::Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unlink(std::move(_client_end), std::move(_request_buffer), std::move(path), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnlinkResponse> DirectoryAdmin::InPlace::Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::UnlinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::UnlinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::UnlinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::ReadDirents_Impl<DirectoryAdmin::ReadDirentsResponse>::ReadDirents_Impl(::zx::unowned_channel _client_end, uint64_t max_bytes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirentsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadDirentsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadDirentsRequest*>(_write_bytes);
+ _request.max_bytes = std::move(max_bytes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadDirentsRequest));
+ ::fidl::DecodedMessage<ReadDirentsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::ReadDirents(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::ReadDirents DirectoryAdmin::SyncClient::ReadDirents(uint64_t max_bytes) {
+ return ResultOf::ReadDirents(::zx::unowned_channel(this->channel_), std::move(max_bytes));
+}
+
+DirectoryAdmin::ResultOf::ReadDirents DirectoryAdmin::Call::ReadDirents(::zx::unowned_channel _client_end, uint64_t max_bytes) {
+ return ResultOf::ReadDirents(std::move(_client_end), std::move(max_bytes));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::ReadDirents_Impl<DirectoryAdmin::ReadDirentsResponse>::ReadDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadDirentsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadDirentsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadDirentsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadDirentsRequest*>(_request_buffer.data());
+ _request.max_bytes = std::move(max_bytes);
+ _request_buffer.set_actual(sizeof(ReadDirentsRequest));
+ ::fidl::DecodedMessage<ReadDirentsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::ReadDirents(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::ReadDirents DirectoryAdmin::SyncClient::ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadDirents(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(max_bytes), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::ReadDirents DirectoryAdmin::Call::ReadDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadDirents(std::move(_client_end), std::move(_request_buffer), std::move(max_bytes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::ReadDirentsResponse> DirectoryAdmin::InPlace::ReadDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::ReadDirentsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::ReadDirentsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadDirentsRequest, ReadDirentsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::ReadDirentsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::Rewind_Impl<DirectoryAdmin::RewindResponse>::Rewind_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RewindRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindRequest));
+ ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Rewind(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Rewind DirectoryAdmin::SyncClient::Rewind() {
+ return ResultOf::Rewind(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::Rewind DirectoryAdmin::Call::Rewind(::zx::unowned_channel _client_end) {
+ return ResultOf::Rewind(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Rewind_Impl<DirectoryAdmin::RewindResponse>::Rewind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(RewindRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, RewindRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(RewindRequest));
+ ::fidl::DecodedMessage<RewindRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Rewind(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Rewind DirectoryAdmin::SyncClient::Rewind(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rewind(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Rewind DirectoryAdmin::Call::Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rewind(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::RewindResponse> DirectoryAdmin::InPlace::Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(RewindRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<RewindRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::RewindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::RewindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RewindRequest, RewindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::RewindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::GetToken_Impl<DirectoryAdmin::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::GetToken DirectoryAdmin::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::GetToken DirectoryAdmin::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::GetToken_Impl<DirectoryAdmin::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::GetToken DirectoryAdmin::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::GetToken DirectoryAdmin::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetTokenResponse> DirectoryAdmin::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::Rename_Impl<DirectoryAdmin::RenameResponse>::Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ RenameRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Rename(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Rename DirectoryAdmin::SyncClient::Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Rename(::zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+DirectoryAdmin::ResultOf::Rename DirectoryAdmin::Call::Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Rename(std::move(_client_end), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Rename_Impl<DirectoryAdmin::RenameResponse>::Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RenameRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RenameResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ RenameRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Rename(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Rename DirectoryAdmin::SyncClient::Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rename(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Rename DirectoryAdmin::Call::Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rename(std::move(_client_end), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::RenameResponse> DirectoryAdmin::InPlace::Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::RenameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::RenameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::RenameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::Link_Impl<DirectoryAdmin::LinkResponse>::Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LinkRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Link(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Link DirectoryAdmin::SyncClient::Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Link(::zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+DirectoryAdmin::ResultOf::Link DirectoryAdmin::Call::Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Link(std::move(_client_end), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Link_Impl<DirectoryAdmin::LinkResponse>::Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LinkRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Link(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Link DirectoryAdmin::SyncClient::Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Link(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Link DirectoryAdmin::Call::Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Link(std::move(_client_end), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::LinkResponse> DirectoryAdmin::InPlace::Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::LinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::LinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::LinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::Watch_Impl<DirectoryAdmin::WatchResponse>::Watch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WatchRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WatchRequest*>(_write_bytes);
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchRequest));
+ ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Watch(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Watch DirectoryAdmin::SyncClient::Watch(uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ return ResultOf::Watch(::zx::unowned_channel(this->channel_), std::move(mask), std::move(options), std::move(watcher));
+}
+
+DirectoryAdmin::ResultOf::Watch DirectoryAdmin::Call::Watch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher) {
+ return ResultOf::Watch(std::move(_client_end), std::move(mask), std::move(options), std::move(watcher));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Watch_Impl<DirectoryAdmin::WatchResponse>::Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WatchRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WatchResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WatchRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WatchRequest*>(_request_buffer.data());
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ _request_buffer.set_actual(sizeof(WatchRequest));
+ ::fidl::DecodedMessage<WatchRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Watch(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Watch DirectoryAdmin::SyncClient::Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Watch(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Watch DirectoryAdmin::Call::Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Watch(std::move(_client_end), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::WatchResponse> DirectoryAdmin::InPlace::Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::WatchRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::WatchResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WatchRequest, WatchResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::WatchResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::Mount_Impl<DirectoryAdmin::MountResponse>::Mount_Impl(::zx::unowned_channel _client_end, ::zx::channel remote) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MountRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, MountRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<MountRequest*>(_write_bytes);
+ _request.remote = std::move(remote);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(MountRequest));
+ ::fidl::DecodedMessage<MountRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Mount(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Mount DirectoryAdmin::SyncClient::Mount(::zx::channel remote) {
+ return ResultOf::Mount(::zx::unowned_channel(this->channel_), std::move(remote));
+}
+
+DirectoryAdmin::ResultOf::Mount DirectoryAdmin::Call::Mount(::zx::unowned_channel _client_end, ::zx::channel remote) {
+ return ResultOf::Mount(std::move(_client_end), std::move(remote));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Mount_Impl<DirectoryAdmin::MountResponse>::Mount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < MountRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<MountResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, MountRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<MountRequest*>(_request_buffer.data());
+ _request.remote = std::move(remote);
+ _request_buffer.set_actual(sizeof(MountRequest));
+ ::fidl::DecodedMessage<MountRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Mount(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Mount DirectoryAdmin::SyncClient::Mount(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Mount(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(remote), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Mount DirectoryAdmin::Call::Mount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Mount(std::move(_client_end), std::move(_request_buffer), std::move(remote), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::MountResponse> DirectoryAdmin::InPlace::Mount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MountRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::MountRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::MountResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<MountRequest, MountResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::MountResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::MountAndCreate_Impl<DirectoryAdmin::MountAndCreateResponse>::MountAndCreate_Impl(::zx::unowned_channel _client_end, ::zx::channel remote, ::fidl::StringView name, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MountAndCreateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ MountAndCreateRequest _request = {};
+ _request.remote = std::move(remote);
+ _request.name = std::move(name);
+ _request.flags = std::move(flags);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<MountAndCreateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirectoryAdmin::InPlace::MountAndCreate(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::MountAndCreate DirectoryAdmin::SyncClient::MountAndCreate(::zx::channel remote, ::fidl::StringView name, uint32_t flags) {
+ return ResultOf::MountAndCreate(::zx::unowned_channel(this->channel_), std::move(remote), std::move(name), std::move(flags));
+}
+
+DirectoryAdmin::ResultOf::MountAndCreate DirectoryAdmin::Call::MountAndCreate(::zx::unowned_channel _client_end, ::zx::channel remote, ::fidl::StringView name, uint32_t flags) {
+ return ResultOf::MountAndCreate(std::move(_client_end), std::move(remote), std::move(name), std::move(flags));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::MountAndCreate_Impl<DirectoryAdmin::MountAndCreateResponse>::MountAndCreate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < MountAndCreateRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<MountAndCreateResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ MountAndCreateRequest _request = {};
+ _request.remote = std::move(remote);
+ _request.name = std::move(name);
+ _request.flags = std::move(flags);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<MountAndCreateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirectoryAdmin::InPlace::MountAndCreate(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::MountAndCreate DirectoryAdmin::SyncClient::MountAndCreate(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::MountAndCreate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(remote), std::move(name), std::move(flags), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::MountAndCreate DirectoryAdmin::Call::MountAndCreate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::MountAndCreate(std::move(_client_end), std::move(_request_buffer), std::move(remote), std::move(name), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::MountAndCreateResponse> DirectoryAdmin::InPlace::MountAndCreate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MountAndCreateRequest> params, ::fidl::BytePart response_buffer) {
+ DirectoryAdmin::SetTransactionHeaderFor::MountAndCreateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::MountAndCreateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<MountAndCreateRequest, MountAndCreateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::MountAndCreateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::Unmount_Impl<DirectoryAdmin::UnmountResponse>::Unmount_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnmountRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, UnmountRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnmountRequest));
+ ::fidl::DecodedMessage<UnmountRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Unmount(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::Unmount DirectoryAdmin::SyncClient::Unmount() {
+ return ResultOf::Unmount(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::Unmount DirectoryAdmin::Call::Unmount(::zx::unowned_channel _client_end) {
+ return ResultOf::Unmount(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::Unmount_Impl<DirectoryAdmin::UnmountResponse>::Unmount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnmountRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, UnmountRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(UnmountRequest));
+ ::fidl::DecodedMessage<UnmountRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::Unmount(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::Unmount DirectoryAdmin::SyncClient::Unmount(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unmount(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::Unmount DirectoryAdmin::Call::Unmount(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unmount(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnmountResponse> DirectoryAdmin::InPlace::Unmount(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(UnmountRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<UnmountRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::UnmountRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::UnmountResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnmountRequest, UnmountResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::UnmountResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::UnmountNode_Impl<DirectoryAdmin::UnmountNodeResponse>::UnmountNode_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnmountNodeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, UnmountNodeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnmountNodeRequest));
+ ::fidl::DecodedMessage<UnmountNodeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::UnmountNode(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::UnmountNode DirectoryAdmin::SyncClient::UnmountNode() {
+ return ResultOf::UnmountNode(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::UnmountNode DirectoryAdmin::Call::UnmountNode(::zx::unowned_channel _client_end) {
+ return ResultOf::UnmountNode(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::UnmountNode_Impl<DirectoryAdmin::UnmountNodeResponse>::UnmountNode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UnmountNodeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, UnmountNodeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(UnmountNodeRequest));
+ ::fidl::DecodedMessage<UnmountNodeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::UnmountNode(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::UnmountNode DirectoryAdmin::SyncClient::UnmountNode(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UnmountNode(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::UnmountNode DirectoryAdmin::Call::UnmountNode(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UnmountNode(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::UnmountNodeResponse> DirectoryAdmin::InPlace::UnmountNode(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(UnmountNodeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<UnmountNodeRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::UnmountNodeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::UnmountNodeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnmountNodeRequest, UnmountNodeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::UnmountNodeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::QueryFilesystem_Impl<DirectoryAdmin::QueryFilesystemResponse>::QueryFilesystem_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryFilesystemRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, QueryFilesystemRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(QueryFilesystemRequest));
+ ::fidl::DecodedMessage<QueryFilesystemRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::QueryFilesystem(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::QueryFilesystem DirectoryAdmin::SyncClient::QueryFilesystem() {
+ return ResultOf::QueryFilesystem(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::QueryFilesystem DirectoryAdmin::Call::QueryFilesystem(::zx::unowned_channel _client_end) {
+ return ResultOf::QueryFilesystem(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::QueryFilesystem_Impl<DirectoryAdmin::QueryFilesystemResponse>::QueryFilesystem_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(QueryFilesystemRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, QueryFilesystemRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(QueryFilesystemRequest));
+ ::fidl::DecodedMessage<QueryFilesystemRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::QueryFilesystem(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::QueryFilesystem DirectoryAdmin::SyncClient::QueryFilesystem(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::QueryFilesystem(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::QueryFilesystem DirectoryAdmin::Call::QueryFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::QueryFilesystem(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::QueryFilesystemResponse> DirectoryAdmin::InPlace::QueryFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(QueryFilesystemRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<QueryFilesystemRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::QueryFilesystemRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::QueryFilesystemResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<QueryFilesystemRequest, QueryFilesystemResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::QueryFilesystemResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirectoryAdmin::ResultOf::GetDevicePath_Impl<DirectoryAdmin::GetDevicePathResponse>::GetDevicePath_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDevicePathRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetDevicePathRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetDevicePathRequest));
+ ::fidl::DecodedMessage<GetDevicePathRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::GetDevicePath(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryAdmin::ResultOf::GetDevicePath DirectoryAdmin::SyncClient::GetDevicePath() {
+ return ResultOf::GetDevicePath(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryAdmin::ResultOf::GetDevicePath DirectoryAdmin::Call::GetDevicePath(::zx::unowned_channel _client_end) {
+ return ResultOf::GetDevicePath(std::move(_client_end));
+}
+
+template <>
+DirectoryAdmin::UnownedResultOf::GetDevicePath_Impl<DirectoryAdmin::GetDevicePathResponse>::GetDevicePath_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetDevicePathRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetDevicePathRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetDevicePathRequest));
+ ::fidl::DecodedMessage<GetDevicePathRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryAdmin::InPlace::GetDevicePath(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryAdmin::UnownedResultOf::GetDevicePath DirectoryAdmin::SyncClient::GetDevicePath(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDevicePath(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryAdmin::UnownedResultOf::GetDevicePath DirectoryAdmin::Call::GetDevicePath(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetDevicePath(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryAdmin::GetDevicePathResponse> DirectoryAdmin::InPlace::GetDevicePath(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetDevicePathRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetDevicePathRequest> params(std::move(_request_buffer));
+ DirectoryAdmin::SetTransactionHeaderFor::GetDevicePathRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::GetDevicePathResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetDevicePathRequest, GetDevicePathResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryAdmin::GetDevicePathResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t DirectoryAdmin::SyncClient::HandleEvents(DirectoryAdmin::EventHandlers handlers) {
+ return DirectoryAdmin::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t DirectoryAdmin::Call::HandleEvents(::zx::unowned_channel client_end, DirectoryAdmin::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kDirectoryAdmin_OnOpen_Ordinal:
+ case kDirectoryAdmin_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool DirectoryAdmin::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDirectoryAdmin_Clone_Ordinal:
+ case kDirectoryAdmin_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Close_Ordinal:
+ case kDirectoryAdmin_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Describe_Ordinal:
+ case kDirectoryAdmin_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Sync_Ordinal:
+ case kDirectoryAdmin_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_GetAttr_Ordinal:
+ case kDirectoryAdmin_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_SetAttr_Ordinal:
+ case kDirectoryAdmin_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_NodeGetFlags_Ordinal:
+ case kDirectoryAdmin_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_NodeSetFlags_Ordinal:
+ case kDirectoryAdmin_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Open_Ordinal:
+ case kDirectoryAdmin_Open_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Open(std::move(message->flags), std::move(message->mode), std::move(message->path), std::move(message->object),
+ Interface::OpenCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Unlink_Ordinal:
+ case kDirectoryAdmin_Unlink_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnlinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Unlink(std::move(message->path),
+ Interface::UnlinkCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_ReadDirents_Ordinal:
+ case kDirectoryAdmin_ReadDirents_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadDirentsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReadDirents(std::move(message->max_bytes),
+ Interface::ReadDirentsCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Rewind_Ordinal:
+ case kDirectoryAdmin_Rewind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RewindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Rewind(
+ Interface::RewindCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_GetToken_Ordinal:
+ case kDirectoryAdmin_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Rename_Ordinal:
+ case kDirectoryAdmin_Rename_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RenameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Rename(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+ Interface::RenameCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Link_Ordinal:
+ case kDirectoryAdmin_Link_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Link(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+ Interface::LinkCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Watch_Ordinal:
+ case kDirectoryAdmin_Watch_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Watch(std::move(message->mask), std::move(message->options), std::move(message->watcher),
+ Interface::WatchCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Mount_Ordinal:
+ case kDirectoryAdmin_Mount_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<MountRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Mount(std::move(message->remote),
+ Interface::MountCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_MountAndCreate_Ordinal:
+ case kDirectoryAdmin_MountAndCreate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<MountAndCreateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->MountAndCreate(std::move(message->remote), std::move(message->name), std::move(message->flags),
+ Interface::MountAndCreateCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_Unmount_Ordinal:
+ case kDirectoryAdmin_Unmount_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnmountRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Unmount(
+ Interface::UnmountCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_UnmountNode_Ordinal:
+ case kDirectoryAdmin_UnmountNode_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnmountNodeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->UnmountNode(
+ Interface::UnmountNodeCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_QueryFilesystem_Ordinal:
+ case kDirectoryAdmin_QueryFilesystem_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<QueryFilesystemRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->QueryFilesystem(
+ Interface::QueryFilesystemCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectoryAdmin_GetDevicePath_Ordinal:
+ case kDirectoryAdmin_GetDevicePath_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetDevicePathRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetDevicePath(
+ Interface::GetDevicePathCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DirectoryAdmin::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DirectoryAdmin::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t DirectoryAdmin::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t DirectoryAdmin::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t DirectoryAdmin::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::UnlinkCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<UnlinkResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::UnlinkResponse(
+ ::fidl::DecodedMessage<UnlinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnlinkResponse::PrimarySize,
+ UnlinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnlinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::UnlinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < UnlinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<UnlinkResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::UnlinkResponse(
+ ::fidl::DecodedMessage<UnlinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnlinkResponse::PrimarySize,
+ UnlinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(UnlinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnlinkResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::UnlinkCompleterBase::Reply(::fidl::DecodedMessage<UnlinkResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::UnlinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::ReadDirentsCompleterBase::Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirentsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadDirentsResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::ReadDirentsResponse(
+ ::fidl::DecodedMessage<ReadDirentsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDirentsResponse::PrimarySize,
+ ReadDirentsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::ReadDirentsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents) {
+ if (_buffer.capacity() < ReadDirentsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadDirentsResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::ReadDirentsResponse(
+ ::fidl::DecodedMessage<ReadDirentsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDirentsResponse::PrimarySize,
+ ReadDirentsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::ReadDirentsCompleterBase::Reply(::fidl::DecodedMessage<ReadDirentsResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::ReadDirentsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::RewindCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RewindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RewindResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::RewindResponse(
+ ::fidl::DecodedMessage<RewindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RewindResponse::PrimarySize,
+ RewindResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RewindResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::RewindCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < RewindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RewindResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::RewindResponse(
+ ::fidl::DecodedMessage<RewindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RewindResponse::PrimarySize,
+ RewindResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(RewindResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RewindResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::RewindCompleterBase::Reply(::fidl::DecodedMessage<RewindResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::RewindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::GetTokenCompleterBase::Reply(int32_t s, ::zx::handle token) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetTokenResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.token = std::move(token);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetTokenResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.token = std::move(token);
+ _buffer.set_actual(sizeof(GetTokenResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetTokenResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::RenameCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RenameResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::RenameResponse(
+ ::fidl::DecodedMessage<RenameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RenameResponse::PrimarySize,
+ RenameResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RenameResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::RenameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < RenameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RenameResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::RenameResponse(
+ ::fidl::DecodedMessage<RenameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RenameResponse::PrimarySize,
+ RenameResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(RenameResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RenameResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::RenameCompleterBase::Reply(::fidl::DecodedMessage<RenameResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::RenameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::LinkCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LinkResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::LinkResponse(
+ ::fidl::DecodedMessage<LinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LinkResponse::PrimarySize,
+ LinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::LinkCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < LinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LinkResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::LinkResponse(
+ ::fidl::DecodedMessage<LinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LinkResponse::PrimarySize,
+ LinkResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(LinkResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LinkResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::LinkCompleterBase::Reply(::fidl::DecodedMessage<LinkResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::LinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::WatchCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WatchResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::WatchResponse(
+ ::fidl::DecodedMessage<WatchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchResponse::PrimarySize,
+ WatchResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WatchResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::WatchCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < WatchResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WatchResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::WatchResponse(
+ ::fidl::DecodedMessage<WatchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WatchResponse::PrimarySize,
+ WatchResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(WatchResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WatchResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::WatchCompleterBase::Reply(::fidl::DecodedMessage<WatchResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::WatchResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::MountCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MountResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<MountResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::MountResponse(
+ ::fidl::DecodedMessage<MountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MountResponse::PrimarySize,
+ MountResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(MountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<MountResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::MountCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < MountResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<MountResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::MountResponse(
+ ::fidl::DecodedMessage<MountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MountResponse::PrimarySize,
+ MountResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(MountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<MountResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::MountCompleterBase::Reply(::fidl::DecodedMessage<MountResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::MountResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::MountAndCreateCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MountAndCreateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<MountAndCreateResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::MountAndCreateResponse(
+ ::fidl::DecodedMessage<MountAndCreateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MountAndCreateResponse::PrimarySize,
+ MountAndCreateResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(MountAndCreateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<MountAndCreateResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::MountAndCreateCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < MountAndCreateResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<MountAndCreateResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::MountAndCreateResponse(
+ ::fidl::DecodedMessage<MountAndCreateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MountAndCreateResponse::PrimarySize,
+ MountAndCreateResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(MountAndCreateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<MountAndCreateResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::MountAndCreateCompleterBase::Reply(::fidl::DecodedMessage<MountAndCreateResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::MountAndCreateResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::UnmountCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnmountResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<UnmountResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::UnmountResponse(
+ ::fidl::DecodedMessage<UnmountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnmountResponse::PrimarySize,
+ UnmountResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnmountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnmountResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::UnmountCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < UnmountResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<UnmountResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::UnmountResponse(
+ ::fidl::DecodedMessage<UnmountResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnmountResponse::PrimarySize,
+ UnmountResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(UnmountResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnmountResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::UnmountCompleterBase::Reply(::fidl::DecodedMessage<UnmountResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::UnmountResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::UnmountNodeCompleterBase::Reply(int32_t s, ::zx::channel remote) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnmountNodeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<UnmountNodeResponse*>(_write_bytes);
+ DirectoryAdmin::SetTransactionHeaderFor::UnmountNodeResponse(
+ ::fidl::DecodedMessage<UnmountNodeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnmountNodeResponse::PrimarySize,
+ UnmountNodeResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.remote = std::move(remote);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UnmountNodeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnmountNodeResponse>(std::move(_response_bytes)));
+}
+
+void DirectoryAdmin::Interface::UnmountNodeCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::zx::channel remote) {
+ if (_buffer.capacity() < UnmountNodeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<UnmountNodeResponse*>(_buffer.data());
+ DirectoryAdmin::SetTransactionHeaderFor::UnmountNodeResponse(
+ ::fidl::DecodedMessage<UnmountNodeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnmountNodeResponse::PrimarySize,
+ UnmountNodeResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.remote = std::move(remote);
+ _buffer.set_actual(sizeof(UnmountNodeResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UnmountNodeResponse>(std::move(_buffer)));
+}
+
+void DirectoryAdmin::Interface::UnmountNodeCompleterBase::Reply(::fidl::DecodedMessage<UnmountNodeResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::UnmountNodeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::QueryFilesystemCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::FilesystemInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryFilesystemResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ QueryFilesystemResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::QueryFilesystemResponse(
+ ::fidl::DecodedMessage<QueryFilesystemResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryFilesystemResponse::PrimarySize,
+ QueryFilesystemResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::QueryFilesystemCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::FilesystemInfo* info) {
+ if (_buffer.capacity() < QueryFilesystemResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ QueryFilesystemResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::QueryFilesystemResponse(
+ ::fidl::DecodedMessage<QueryFilesystemResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryFilesystemResponse::PrimarySize,
+ QueryFilesystemResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::QueryFilesystemCompleterBase::Reply(::fidl::DecodedMessage<QueryFilesystemResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::QueryFilesystemResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirectoryAdmin::Interface::GetDevicePathCompleterBase::Reply(int32_t s, ::fidl::StringView path) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetDevicePathResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetDevicePathResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::GetDevicePathResponse(
+ ::fidl::DecodedMessage<GetDevicePathResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDevicePathResponse::PrimarySize,
+ GetDevicePathResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::GetDevicePathCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::StringView path) {
+ if (_buffer.capacity() < GetDevicePathResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetDevicePathResponse _response = {};
+ DirectoryAdmin::SetTransactionHeaderFor::GetDevicePathResponse(
+ ::fidl::DecodedMessage<GetDevicePathResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetDevicePathResponse::PrimarySize,
+ GetDevicePathResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryAdmin::Interface::GetDevicePathCompleterBase::Reply(::fidl::DecodedMessage<GetDevicePathResponse> params) {
+ DirectoryAdmin::SetTransactionHeaderFor::GetDevicePathResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DirectoryAdmin::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<DirectoryAdmin::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<DirectoryAdmin::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<DirectoryAdmin::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<DirectoryAdmin::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<DirectoryAdmin::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<DirectoryAdmin::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<DirectoryAdmin::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<DirectoryAdmin::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<DirectoryAdmin::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<DirectoryAdmin::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::OpenRequest(const ::fidl::DecodedMessage<DirectoryAdmin::OpenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Open_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::UnlinkRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnlinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Unlink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::UnlinkResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnlinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Unlink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::ReadDirentsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::ReadDirentsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_ReadDirents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::ReadDirentsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::ReadDirentsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_ReadDirents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::RewindRequest(const ::fidl::DecodedMessage<DirectoryAdmin::RewindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Rewind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::RewindResponse(const ::fidl::DecodedMessage<DirectoryAdmin::RewindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Rewind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::RenameRequest(const ::fidl::DecodedMessage<DirectoryAdmin::RenameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Rename_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::RenameResponse(const ::fidl::DecodedMessage<DirectoryAdmin::RenameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Rename_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::LinkRequest(const ::fidl::DecodedMessage<DirectoryAdmin::LinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Link_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::LinkResponse(const ::fidl::DecodedMessage<DirectoryAdmin::LinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Link_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::WatchRequest(const ::fidl::DecodedMessage<DirectoryAdmin::WatchRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Watch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::WatchResponse(const ::fidl::DecodedMessage<DirectoryAdmin::WatchResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Watch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::MountRequest(const ::fidl::DecodedMessage<DirectoryAdmin::MountRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Mount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::MountResponse(const ::fidl::DecodedMessage<DirectoryAdmin::MountResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Mount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::MountAndCreateRequest(const ::fidl::DecodedMessage<DirectoryAdmin::MountAndCreateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_MountAndCreate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::MountAndCreateResponse(const ::fidl::DecodedMessage<DirectoryAdmin::MountAndCreateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_MountAndCreate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::UnmountRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Unmount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::UnmountResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_Unmount_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::UnmountNodeRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountNodeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_UnmountNode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::UnmountNodeResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountNodeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_UnmountNode_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::QueryFilesystemRequest(const ::fidl::DecodedMessage<DirectoryAdmin::QueryFilesystemRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_QueryFilesystem_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::QueryFilesystemResponse(const ::fidl::DecodedMessage<DirectoryAdmin::QueryFilesystemResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_QueryFilesystem_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirectoryAdmin::SetTransactionHeaderFor::GetDevicePathRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetDevicePathRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_GetDevicePath_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryAdmin::SetTransactionHeaderFor::GetDevicePathResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetDevicePathResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryAdmin_GetDevicePath_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace io
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-io/gen/llcpp/include/fuchsia/io/llcpp/fidl.h b/zircon/system/fidl/fuchsia-io/gen/llcpp/include/fuchsia/io/llcpp/fidl.h
new file mode 100644
index 0000000..6ff0dbd
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-io/gen/llcpp/include/fuchsia/io/llcpp/fidl.h
@@ -0,0 +1,10508 @@
+// 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/event.h>
+#include <lib/zx/eventpair.h>
+#include <lib/zx/handle.h>
+#include <lib/zx/socket.h>
+#include <lib/zx/vmo.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/mem/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace io {
+
+struct WatchedEvent;
+struct Vmofile;
+struct Tty;
+struct StreamSocket;
+class DirectoryWatcher;
+struct Socket;
+struct Service;
+enum class SeekOrigin : uint32_t {
+ START = 0u,
+ CURRENT = 1u,
+ END = 2u,
+};
+
+
+struct Pipe;
+struct NodeAttributes;
+struct FilesystemInfo;
+struct FileObject;
+struct DirectoryObject;
+struct Device;
+struct DatagramSocket;
+struct NodeInfo;
+class Node;
+class File;
+class Directory;
+class DirectoryAdmin;
+
+extern "C" const fidl_type_t v1_fuchsia_io_NodeInfoTable;
+
+// Describes how the connection to an should be handled, as well as
+// how to interpret the optional handle.
+//
+// Refer to `Node.Describe()` and `Node.OnOpen()` for usage.
+struct NodeInfo {
+ NodeInfo() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kService = 1, // 0x1
+ kFile = 2, // 0x2
+ kDirectory = 3, // 0x3
+ kPipe = 4, // 0x4
+ kVmofile = 5, // 0x5
+ kDevice = 6, // 0x6
+ kTty = 7, // 0x7
+ kSocket = 8, // 0x8
+ kDatagramSocket = 9, // 0x9
+ kStreamSocket = 10, // 0xa
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_service() const { return ordinal() == Ordinal::kService; }
+
+ static NodeInfo WithService(::llcpp::fuchsia::io::Service* val) {
+ NodeInfo result;
+ result.set_service(val);
+ return result;
+ }
+
+ void set_service(::llcpp::fuchsia::io::Service* elem) {
+ ordinal_ = Ordinal::kService;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::Service& mutable_service() {
+ ZX_ASSERT(ordinal() == Ordinal::kService);
+ return *static_cast<::llcpp::fuchsia::io::Service*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::Service& service() const {
+ ZX_ASSERT(ordinal() == Ordinal::kService);
+ return *static_cast<::llcpp::fuchsia::io::Service*>(envelope_.data);
+ }
+
+ bool is_file() const { return ordinal() == Ordinal::kFile; }
+
+ static NodeInfo WithFile(::llcpp::fuchsia::io::FileObject* val) {
+ NodeInfo result;
+ result.set_file(val);
+ return result;
+ }
+
+ void set_file(::llcpp::fuchsia::io::FileObject* elem) {
+ ordinal_ = Ordinal::kFile;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::FileObject& mutable_file() {
+ ZX_ASSERT(ordinal() == Ordinal::kFile);
+ return *static_cast<::llcpp::fuchsia::io::FileObject*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::FileObject& file() const {
+ ZX_ASSERT(ordinal() == Ordinal::kFile);
+ return *static_cast<::llcpp::fuchsia::io::FileObject*>(envelope_.data);
+ }
+
+ bool is_directory() const { return ordinal() == Ordinal::kDirectory; }
+
+ static NodeInfo WithDirectory(::llcpp::fuchsia::io::DirectoryObject* val) {
+ NodeInfo result;
+ result.set_directory(val);
+ return result;
+ }
+
+ void set_directory(::llcpp::fuchsia::io::DirectoryObject* elem) {
+ ordinal_ = Ordinal::kDirectory;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::DirectoryObject& mutable_directory() {
+ ZX_ASSERT(ordinal() == Ordinal::kDirectory);
+ return *static_cast<::llcpp::fuchsia::io::DirectoryObject*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::DirectoryObject& directory() const {
+ ZX_ASSERT(ordinal() == Ordinal::kDirectory);
+ return *static_cast<::llcpp::fuchsia::io::DirectoryObject*>(envelope_.data);
+ }
+
+ bool is_pipe() const { return ordinal() == Ordinal::kPipe; }
+
+ static NodeInfo WithPipe(::llcpp::fuchsia::io::Pipe* val) {
+ NodeInfo result;
+ result.set_pipe(val);
+ return result;
+ }
+
+ void set_pipe(::llcpp::fuchsia::io::Pipe* elem) {
+ ordinal_ = Ordinal::kPipe;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::Pipe& mutable_pipe() {
+ ZX_ASSERT(ordinal() == Ordinal::kPipe);
+ return *static_cast<::llcpp::fuchsia::io::Pipe*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::Pipe& pipe() const {
+ ZX_ASSERT(ordinal() == Ordinal::kPipe);
+ return *static_cast<::llcpp::fuchsia::io::Pipe*>(envelope_.data);
+ }
+
+ bool is_vmofile() const { return ordinal() == Ordinal::kVmofile; }
+
+ static NodeInfo WithVmofile(::llcpp::fuchsia::io::Vmofile* val) {
+ NodeInfo result;
+ result.set_vmofile(val);
+ return result;
+ }
+
+ void set_vmofile(::llcpp::fuchsia::io::Vmofile* elem) {
+ ordinal_ = Ordinal::kVmofile;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::Vmofile& mutable_vmofile() {
+ ZX_ASSERT(ordinal() == Ordinal::kVmofile);
+ return *static_cast<::llcpp::fuchsia::io::Vmofile*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::Vmofile& vmofile() const {
+ ZX_ASSERT(ordinal() == Ordinal::kVmofile);
+ return *static_cast<::llcpp::fuchsia::io::Vmofile*>(envelope_.data);
+ }
+
+ bool is_device() const { return ordinal() == Ordinal::kDevice; }
+
+ static NodeInfo WithDevice(::llcpp::fuchsia::io::Device* val) {
+ NodeInfo result;
+ result.set_device(val);
+ return result;
+ }
+
+ void set_device(::llcpp::fuchsia::io::Device* elem) {
+ ordinal_ = Ordinal::kDevice;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::Device& mutable_device() {
+ ZX_ASSERT(ordinal() == Ordinal::kDevice);
+ return *static_cast<::llcpp::fuchsia::io::Device*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::Device& device() const {
+ ZX_ASSERT(ordinal() == Ordinal::kDevice);
+ return *static_cast<::llcpp::fuchsia::io::Device*>(envelope_.data);
+ }
+
+ bool is_tty() const { return ordinal() == Ordinal::kTty; }
+
+ static NodeInfo WithTty(::llcpp::fuchsia::io::Tty* val) {
+ NodeInfo result;
+ result.set_tty(val);
+ return result;
+ }
+
+ void set_tty(::llcpp::fuchsia::io::Tty* elem) {
+ ordinal_ = Ordinal::kTty;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::Tty& mutable_tty() {
+ ZX_ASSERT(ordinal() == Ordinal::kTty);
+ return *static_cast<::llcpp::fuchsia::io::Tty*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::Tty& tty() const {
+ ZX_ASSERT(ordinal() == Ordinal::kTty);
+ return *static_cast<::llcpp::fuchsia::io::Tty*>(envelope_.data);
+ }
+
+ bool is_socket() const { return ordinal() == Ordinal::kSocket; }
+
+ static NodeInfo WithSocket(::llcpp::fuchsia::io::Socket* val) {
+ NodeInfo result;
+ result.set_socket(val);
+ return result;
+ }
+
+ void set_socket(::llcpp::fuchsia::io::Socket* elem) {
+ ordinal_ = Ordinal::kSocket;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::Socket& mutable_socket() {
+ ZX_ASSERT(ordinal() == Ordinal::kSocket);
+ return *static_cast<::llcpp::fuchsia::io::Socket*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::Socket& socket() const {
+ ZX_ASSERT(ordinal() == Ordinal::kSocket);
+ return *static_cast<::llcpp::fuchsia::io::Socket*>(envelope_.data);
+ }
+
+ bool is_datagram_socket() const { return ordinal() == Ordinal::kDatagramSocket; }
+
+ static NodeInfo WithDatagramSocket(::llcpp::fuchsia::io::DatagramSocket* val) {
+ NodeInfo result;
+ result.set_datagram_socket(val);
+ return result;
+ }
+
+ void set_datagram_socket(::llcpp::fuchsia::io::DatagramSocket* elem) {
+ ordinal_ = Ordinal::kDatagramSocket;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::DatagramSocket& mutable_datagram_socket() {
+ ZX_ASSERT(ordinal() == Ordinal::kDatagramSocket);
+ return *static_cast<::llcpp::fuchsia::io::DatagramSocket*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::DatagramSocket& datagram_socket() const {
+ ZX_ASSERT(ordinal() == Ordinal::kDatagramSocket);
+ return *static_cast<::llcpp::fuchsia::io::DatagramSocket*>(envelope_.data);
+ }
+
+ bool is_stream_socket() const { return ordinal() == Ordinal::kStreamSocket; }
+
+ static NodeInfo WithStreamSocket(::llcpp::fuchsia::io::StreamSocket* val) {
+ NodeInfo result;
+ result.set_stream_socket(val);
+ return result;
+ }
+
+ void set_stream_socket(::llcpp::fuchsia::io::StreamSocket* elem) {
+ ordinal_ = Ordinal::kStreamSocket;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io::StreamSocket& mutable_stream_socket() {
+ ZX_ASSERT(ordinal() == Ordinal::kStreamSocket);
+ return *static_cast<::llcpp::fuchsia::io::StreamSocket*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io::StreamSocket& stream_socket() const {
+ ZX_ASSERT(ordinal() == Ordinal::kStreamSocket);
+ return *static_cast<::llcpp::fuchsia::io::StreamSocket*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kService = 1, // 0x1
+ kFile = 2, // 0x2
+ kDirectory = 3, // 0x3
+ kPipe = 4, // 0x4
+ kVmofile = 5, // 0x5
+ kDevice = 6, // 0x6
+ kTty = 7, // 0x7
+ kSocket = 8, // 0x8
+ kDatagramSocket = 9, // 0x9
+ kStreamSocket = 10, // 0xa
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_WatchedEventTable;
+
+// WatchedEvent describes events returned from a DirectoryWatcher.
+struct WatchedEvent {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_WatchedEventTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 256;
+ static constexpr bool HasPointer = true;
+
+ uint8_t event = {};
+
+ uint8_t len = {};
+
+ ::fidl::VectorView<uint8_t> name = {};
+};
+
+// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_REMOVED`.
+constexpr uint32_t WATCH_MASK_REMOVED = 4u;
+
+// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_IDLE`.
+constexpr uint32_t WATCH_MASK_IDLE = 16u;
+
+// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_EXISTING`.
+constexpr uint32_t WATCH_MASK_EXISTING = 8u;
+
+// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_DELETED`.
+constexpr uint32_t WATCH_MASK_DELETED = 1u;
+
+// Used by `Directory.Watch`. Requests transmission of all watcher events.
+constexpr uint32_t WATCH_MASK_ALL = 31u;
+
+// Used by `Directory.Watch`. Requests transmission of `WATCH_EVENT_ADDED`.
+constexpr uint32_t WATCH_MASK_ADDED = 2u;
+
+// Identifies a node has been removed (either deleted or moved) from the directory.
+constexpr uint8_t WATCH_EVENT_REMOVED = 2u;
+
+// Identifies that no more `WATCH_EVENT_EXISTING` events will be sent.
+constexpr uint8_t WATCH_EVENT_IDLE = 4u;
+
+// Identifies a node already existed in the directory when watching started.
+constexpr uint8_t WATCH_EVENT_EXISTING = 3u;
+
+// Indicates the directory being watched has been deleted.
+constexpr uint8_t WATCH_EVENT_DELETED = 0u;
+
+// Indicates a node has been created (either new or moved) into a directory.
+constexpr uint8_t WATCH_EVENT_ADDED = 1u;
+
+extern "C" const fidl_type_t v1_fuchsia_io_VmofileTable;
+
+// The object is a file which is represented as an immutable VMO.
+// Although a VMO is returned as a part of this structure, this underlying object
+// may represent multiple Vmofiles. To identify the logical portion of the VMO
+// that represents the single file, an offset and length parameter are also supplied.
+struct Vmofile {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_VmofileTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The VMO which backs this file.
+ ::zx::vmo vmo = {};
+
+ // The index into `vmo` which represents the first byte of the file.
+ uint64_t offset = {};
+
+ // The number of bytes, starting at `offset`, which may be used to represent this file.
+ uint64_t length = {};
+};
+
+// Requests that the VMO be writable.
+constexpr uint32_t VMO_FLAG_WRITE = 2u;
+
+// Requests that the VMO be readable.
+constexpr uint32_t VMO_FLAG_READ = 1u;
+
+// Require a copy-on-write clone of the underlying VMO.
+// The request should fail if the VMO is not cloned.
+// May not be supplied with fuchsia_io_`VMO_FLAG_EXACT`.
+constexpr uint32_t VMO_FLAG_PRIVATE = 65536u;
+
+// Requests that the VMO be executable.
+constexpr uint32_t VMO_FLAG_EXEC = 4u;
+
+// Require an exact (non-cloned) handle to the underlying VMO.
+// The request should fail if a handle to the exact VMO is not returned.
+// May not be supplied with `VMO_FLAG_PRIVATE`.
+constexpr uint32_t VMO_FLAG_EXACT = 131072u;
+
+extern "C" const fidl_type_t v1_fuchsia_io_TtyTable;
+
+// The object may be cast to interface 'Tty'
+struct Tty {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_TtyTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::eventpair event = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_StreamSocketTable;
+
+// The object may be cast to interface [`fuchsia.posix.socket.StreamSocket`].
+struct StreamSocket {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_StreamSocketTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::socket socket = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatcherOnEventRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatcherOnEventResponseTable;
+
+// DirectoryWatcher transmits messages from a filesystem server
+// about events happening in the filesystem. Clients can register
+// new watchers using the `Directory.Watch` method, where they can
+// filter which events they want to receive notifications for.
+class DirectoryWatcher final {
+ DirectoryWatcher() = delete;
+ public:
+
+ struct OnEventRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> events;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryWatcherOnEventRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class OnEvent_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OnEvent_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> events);
+ ~OnEvent_Impl() = default;
+ OnEvent_Impl(OnEvent_Impl&& other) = default;
+ OnEvent_Impl& operator=(OnEvent_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using OnEvent = OnEvent_Impl;
+ };
+
+ // 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:
+ class OnEvent_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OnEvent_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events);
+ ~OnEvent_Impl() = default;
+ OnEvent_Impl(OnEvent_Impl&& other) = default;
+ OnEvent_Impl& operator=(OnEvent_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using OnEvent = OnEvent_Impl;
+ };
+
+ 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_; }
+
+ // Request is heap-allocated.
+ ResultOf::OnEvent OnEvent(::fidl::VectorView<uint8_t> events);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OnEvent OnEvent(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events);
+
+ 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:
+
+ // Request is heap-allocated.
+ static ResultOf::OnEvent OnEvent(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> events);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OnEvent OnEvent(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> events);
+
+ };
+
+ // 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::internal::StatusAndError OnEvent(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnEventRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DirectoryWatcher;
+ using _Base = ::fidl::CompleterBase;
+
+ using OnEventCompleter = ::fidl::Completer<>;
+
+ virtual void OnEvent(::fidl::VectorView<uint8_t> events, OnEventCompleter::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 OnEventRequest(const ::fidl::DecodedMessage<DirectoryWatcher::OnEventRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_SocketTable;
+
+// The object may be cast to interface [`fuchsia.posix.socket.Control`].
+struct Socket {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_SocketTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::socket socket = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_ServiceTable;
+
+// The default protocol, interface information must be acquired some
+// other way.
+struct Service {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_ServiceTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_PipeTable;
+
+// The object is accompanied by a pipe.
+struct Pipe {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_PipeTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::socket socket = {};
+};
+
+// Can write to target object.
+constexpr uint32_t OPEN_RIGHT_WRITABLE = 2u;
+
+// Can read from target object.
+constexpr uint32_t OPEN_RIGHT_READABLE = 1u;
+
+// Connection can map target object executable.
+constexpr uint32_t OPEN_RIGHT_EXECUTABLE = 8u;
+
+// Connection can mount/umount filesystem.
+constexpr uint32_t OPEN_RIGHT_ADMIN = 4u;
+
+// Truncate the object before usage.
+constexpr uint32_t OPEN_FLAG_TRUNCATE = 262144u;
+
+// Specify this flag to request POSIX-compatibility. Currently, it affects permission handling.
+// During Open:
+// - If the target path is a directory, the rights on the new connection expand to include
+// `OPEN_RIGHT_WRITABLE` if and only if the current connection and all intermediate mount points
+// are writable, and to include `OPEN_RIGHT_EXECUTABLE` if and only if the current connection and
+// all intermediate mount points are executable.
+// - Otherwise, this flag is ignored. It is an access denied error to request more rights
+// than those on the current connection, or any intermediate mount points.
+//
+// If the posix compatibility flag is not specified, opening always uses the requested rights,
+// failing the operation with access denied error if requested rights exceeds the rights attached
+// to the current connection.
+//
+// If the requesting connection is read-only and the requested rights are read-only, the flag
+// may be ignored by the server, and is not forwarded downstream. This is an implementation detail,
+// necessary to enforce hierarchical permissions across mount points, and should have no effect
+// on the expected behavior for clients.
+constexpr uint32_t OPEN_FLAG_POSIX = 16777216u;
+
+// If the object is a mount point, open the local directory.
+constexpr uint32_t OPEN_FLAG_NO_REMOTE = 2097152u;
+
+// Assert that the object to be opened is not a directory.
+// Return an error if the target object is a directory.
+constexpr uint32_t OPEN_FLAG_NOT_DIRECTORY = 33554432u;
+
+// Open a reference to the object, not the object itself.
+// It is ONLY valid to pass the following flags together with `OPEN_FLAG_NODE_REFERENCE`:
+// - `OPEN_FLAG_DIRECTORY`
+// - `OPEN_FLAG_NOT_DIRECTORY`
+// - `OPEN_FLAG_DESCRIBE`
+// otherwise an error is returned.
+// If an object is opened or cloned using this method, the resulting connection does not carry
+// any permission flags.
+// The resulting node allows a limited set of operations: `GetAttr`, `Clone`, `Close`, `Describe`,
+// and, if the node is a file, these extra operations: `GetFlags`, `SetFlags`.
+constexpr uint32_t OPEN_FLAG_NODE_REFERENCE = 4194304u;
+
+// Assert that the object to be opened is a directory.
+// Return an error if the target object is not a directory.
+constexpr uint32_t OPEN_FLAG_DIRECTORY = 524288u;
+
+// Requests that an "OnOpen" event is sent to the interface request.
+// The event will contain a non-null NodeInfo if the open/clone is successful.
+constexpr uint32_t OPEN_FLAG_DESCRIBE = 8388608u;
+
+// (with Create) Fail if the object already exists.
+constexpr uint32_t OPEN_FLAG_CREATE_IF_ABSENT = 131072u;
+
+// Create the object if it doesn't exist.
+constexpr uint32_t OPEN_FLAG_CREATE = 65536u;
+
+// Seek to the end of the object before all writes.
+constexpr uint32_t OPEN_FLAG_APPEND = 1048576u;
+
+// Binary OR of `OPEN_FLAG_DIRECTORY`, OPEN_FLAG_NOT_DIRECTORY, OPEN_FLAG_DESCRIBE, and
+// `OPEN_FLAG_NODE_REFERENCE`. Flags used when opening a node reference must fall within this mask.
+constexpr uint32_t OPEN_FLAGS_ALLOWED_WITH_NODE_REFERENCE = 46661632u;
+
+extern "C" const fidl_type_t v1_fuchsia_io_NodeAttributesTable;
+
+// NodeAttributes defines generic information about a filesystem node.
+struct NodeAttributes {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeAttributesTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Protection bits and node type information describe in 'mode'.
+ uint32_t mode = {};
+
+ // A filesystem-unique ID.
+ uint64_t id = {};
+
+ // Node size, in bytes.
+ uint64_t content_size = {};
+
+ // Space needed to store node (possibly larger than size), in bytes.
+ uint64_t storage_size = {};
+
+ // Hard link count.
+ uint64_t link_count = {};
+
+ // Time of creation (may be updated manually after creation) in ns since Unix epoch, UTC.
+ uint64_t creation_time = {};
+
+ // Time of last modification in ns since Unix epoch, UTC.
+ uint64_t modification_time = {};
+};
+
+constexpr uint32_t NODE_ATTRIBUTE_FLAG_MODIFICATION_TIME = 2u;
+
+// The fields of 'attributes' which are used to update the Node are indicated
+// by the 'flags' argument.
+constexpr uint32_t NODE_ATTRIBUTE_FLAG_CREATION_TIME = 1u;
+
+constexpr uint32_t MOUNT_CREATE_FLAG_REPLACE = 1u;
+
+constexpr uint32_t MODE_TYPE_SOCKET = 49152u;
+
+constexpr uint32_t MODE_TYPE_SERVICE = 65536u;
+
+// Bits indicating node type. The canonical mechanism to check
+// for a node type is to take 'mode', bitwise AND it with the
+// `MODE_TYPE_MASK`, and check exact equality against a mode type.
+constexpr uint32_t MODE_TYPE_MASK = 1044480u;
+
+constexpr uint32_t MODE_TYPE_FILE = 32768u;
+
+constexpr uint32_t MODE_TYPE_DIRECTORY = 16384u;
+
+constexpr uint32_t MODE_TYPE_BLOCK_DEVICE = 24576u;
+
+// Bits reserved for posix protections. Native fuchsia filesystems
+// are not required to set bits contained within `MODE_PROTECTION_MASK`,
+// but filesystems that wish to do so may refer to sys/stat.h for their
+// definitions.
+constexpr uint32_t MODE_PROTECTION_MASK = 4095u;
+
+// The maximum length, in bytes, of a filesystem string.
+constexpr uint64_t MAX_PATH = 4096u;
+
+constexpr uint64_t MAX_FS_NAME_BUFFER = 32u;
+
+// The maximum length, in bytes, of a single filesystem component.
+constexpr uint64_t MAX_FILENAME = 255u;
+
+// The maximal buffer size which can be transmitted for buffered operations.
+// This capacity is currently set somewhat arbitrarily.
+constexpr uint64_t MAX_BUF = 8192u;
+
+// Nodes which do not have ino values should return this value
+// from Readdir and GetAttr.
+constexpr uint64_t INO_UNKNOWN = 18446744073709551615u;
+
+extern "C" const fidl_type_t v1_fuchsia_io_FilesystemInfoTable;
+
+struct FilesystemInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FilesystemInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 96;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The number of data bytes which may be stored in a filesystem.
+ uint64_t total_bytes = {};
+
+ // The number of data bytes which are in use by the filesystem.
+ uint64_t used_bytes = {};
+
+ // The number of nodes which may be stored in the filesystem.
+ uint64_t total_nodes = {};
+
+ // The number of nodes used by the filesystem.
+ uint64_t used_nodes = {};
+
+ // The amount of space which may be allocated from the underlying
+ // volume manager. If unsupported, this will be zero.
+ uint64_t free_shared_pool_bytes = {};
+
+ // A unique identifier for this filesystem instance. Will not be preserved
+ // across reboots.
+ uint64_t fs_id = {};
+
+ // The size of a single filesystem block.
+ uint32_t block_size = {};
+
+ // The maximum length of a filesystem name.
+ uint32_t max_filename_size = {};
+
+ // A unique identifier for the type of the underlying filesystem.
+ uint32_t fs_type = {};
+
+ uint32_t padding = {};
+
+ ::fidl::Array<int8_t, 32> name = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_FileObjectTable;
+
+// The object may be cast to interface 'File'.
+struct FileObject {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileObjectTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // An optional event which transmits information about an object's readability
+ // or writability. This event relays information about the underlying object, not
+ // the capability granted to client: this event may be signalled "readable" on a
+ // connection that does not have the capability to read.
+ //
+ // The "`FILE_SIGNAL_`" values may be observed on this event.
+ ::zx::event event = {};
+};
+
+// Indicates the file is ready for writing.
+constexpr uint32_t FILE_SIGNAL_WRITABLE = 33554432u;
+
+// Indicates the file is ready for reading.
+constexpr uint32_t FILE_SIGNAL_READABLE = 16777216u;
+
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryObjectTable;
+
+// The object may be cast to interface 'Directory'.
+struct DirectoryObject {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryObjectTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_DeviceTable;
+
+// The object may be cast to interface 'Device'.
+struct Device {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DeviceTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // An optional event which transmits information about a device's state.
+ //
+ // The "`DEVICE_SIGNAL_`" values may be observed on this event.
+ ::zx::eventpair event = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_DatagramSocketTable;
+
+// The object may be cast to interface [`fuchsia.posix.socket.DatagramSocket`].
+struct DatagramSocket {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DatagramSocketTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // See [`fuchsia.posix.socket.DatagramSocket`] for details.
+ ::zx::eventpair event = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_NodeCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_NodeNodeSetFlagsResponseTable;
+
+// Node defines the minimal interface for entities which can be accessed in a filesystem.
+class Node final {
+ Node() = delete;
+ public:
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_NodeNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Node;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ };
+
+ // 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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<Node::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Node::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<Node::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Node::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Node::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<Node::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Node::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Node::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<Node::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<Node::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<Node::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<Node::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<Node::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<Node::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<Node::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<Node::NodeSetFlagsResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_FileCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileReadResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileReadAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileReadAtResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileWriteResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileWriteAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileWriteAtResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSeekRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSeekResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileTruncateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileTruncateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_FileGetBufferResponseTable;
+
+// File defines the interface of a node which contains a flat layout of data.
+class File final {
+ File() = delete;
+ public:
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct ReadResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileReadResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 ReadRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileReadRequestTable;
+ 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 = ReadResponse;
+ };
+
+ struct ReadAtResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileReadAtResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 ReadAtRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t count;
+ uint64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileReadAtRequestTable;
+ 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 = ReadAtResponse;
+ };
+
+ struct WriteResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint64_t actual;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileWriteResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 WriteRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileWriteRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = WriteResponse;
+ };
+
+ struct WriteAtResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint64_t actual;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileWriteAtResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 WriteAtRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> data;
+ uint64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileWriteAtRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = WriteAtResponse;
+ };
+
+ struct SeekResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSeekResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 SeekRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int64_t offset;
+ ::llcpp::fuchsia::io::SeekOrigin start;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSeekRequestTable;
+ 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 = SeekResponse;
+ };
+
+ struct TruncateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileTruncateResponseTable;
+ 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 TruncateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t length;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileTruncateRequestTable;
+ 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 = TruncateResponse;
+ };
+
+ struct GetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileGetFlagsResponseTable;
+ 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 GetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSetFlagsResponseTable;
+ 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 SetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileSetFlagsRequestTable;
+ 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 = SetFlagsResponse;
+ };
+
+ struct GetBufferResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::mem::Buffer* buffer;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileGetBufferResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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;
+ };
+ struct GetBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_FileGetBufferRequestTable;
+ 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 = GetBufferResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Read_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, uint64_t count);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 ReadAt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadAt_Impl(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset);
+ ~ReadAt_Impl() = default;
+ ReadAt_Impl(ReadAt_Impl&& other) = default;
+ ReadAt_Impl& operator=(ReadAt_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 Write_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 WriteAt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset);
+ ~WriteAt_Impl() = default;
+ WriteAt_Impl(WriteAt_Impl&& other) = default;
+ WriteAt_Impl& operator=(WriteAt_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 Seek_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Seek_Impl(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);
+ ~Seek_Impl() = default;
+ Seek_Impl(Seek_Impl&& other) = default;
+ Seek_Impl& operator=(Seek_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 Truncate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Truncate_Impl(::zx::unowned_channel _client_end, uint64_t length);
+ ~Truncate_Impl() = default;
+ Truncate_Impl(Truncate_Impl&& other) = default;
+ Truncate_Impl& operator=(Truncate_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 GetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetFlags_Impl(::zx::unowned_channel _client_end);
+ ~GetFlags_Impl() = default;
+ GetFlags_Impl(GetFlags_Impl&& other) = default;
+ GetFlags_Impl& operator=(GetFlags_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 SetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~SetFlags_Impl() = default;
+ SetFlags_Impl(SetFlags_Impl&& other) = default;
+ SetFlags_Impl& operator=(SetFlags_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 GetBuffer_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetBuffer_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~GetBuffer_Impl() = default;
+ GetBuffer_Impl(GetBuffer_Impl&& other) = default;
+ GetBuffer_Impl& operator=(GetBuffer_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using ReadAt = ReadAt_Impl<ReadAtResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using WriteAt = WriteAt_Impl<WriteAtResponse>;
+ using Seek = Seek_Impl<SeekResponse>;
+ using Truncate = Truncate_Impl<TruncateResponse>;
+ using GetFlags = GetFlags_Impl<GetFlagsResponse>;
+ using SetFlags = SetFlags_Impl<SetFlagsResponse>;
+ using GetBuffer = GetBuffer_Impl<GetBufferResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Read_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 ReadAt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+ ~ReadAt_Impl() = default;
+ ReadAt_Impl(ReadAt_Impl&& other) = default;
+ ReadAt_Impl& operator=(ReadAt_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 Write_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 WriteAt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+ ~WriteAt_Impl() = default;
+ WriteAt_Impl(WriteAt_Impl&& other) = default;
+ WriteAt_Impl& operator=(WriteAt_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 Seek_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Seek_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);
+ ~Seek_Impl() = default;
+ Seek_Impl(Seek_Impl&& other) = default;
+ Seek_Impl& operator=(Seek_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 Truncate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Truncate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+ ~Truncate_Impl() = default;
+ Truncate_Impl(Truncate_Impl&& other) = default;
+ Truncate_Impl& operator=(Truncate_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 GetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetFlags_Impl() = default;
+ GetFlags_Impl(GetFlags_Impl&& other) = default;
+ GetFlags_Impl& operator=(GetFlags_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 SetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~SetFlags_Impl() = default;
+ SetFlags_Impl(SetFlags_Impl&& other) = default;
+ SetFlags_Impl& operator=(SetFlags_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 GetBuffer_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~GetBuffer_Impl() = default;
+ GetBuffer_Impl(GetBuffer_Impl&& other) = default;
+ GetBuffer_Impl& operator=(GetBuffer_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using ReadAt = ReadAt_Impl<ReadAtResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using WriteAt = WriteAt_Impl<WriteAtResponse>;
+ using Seek = Seek_Impl<SeekResponse>;
+ using Truncate = Truncate_Impl<TruncateResponse>;
+ using GetFlags = GetFlags_Impl<GetFlagsResponse>;
+ using SetFlags = SetFlags_Impl<SetFlagsResponse>;
+ using GetBuffer = GetBuffer_Impl<GetBufferResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Read Read(uint64_t count);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Read Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::ReadAt ReadAt(uint64_t count, uint64_t offset);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadAt ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Write Write(::fidl::VectorView<uint8_t> data);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Write Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::WriteAt WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteAt WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Seek Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Seek Seek(::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Truncate Truncate(uint64_t length);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Truncate Truncate(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetFlags GetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetFlags GetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetFlags SetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetFlags SetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetBuffer GetBuffer(uint32_t flags);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetBuffer GetBuffer(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Read Read(::zx::unowned_channel _client_end, uint64_t count);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Read Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::ReadAt ReadAt(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadAt ReadAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::WriteAt WriteAt(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteAt WriteAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Seek Seek(::zx::unowned_channel _client_end, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Seek Seek(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, ::fidl::BytePart _response_buffer);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Truncate Truncate(::zx::unowned_channel _client_end, uint64_t length);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Truncate Truncate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetFlags GetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetFlags GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetFlags SetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetFlags SetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetBuffer GetBuffer(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetBuffer GetBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads `count` bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ static ::fidl::DecodeResult<ReadResponse> Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads `count` bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_READABLE`.
+ static ::fidl::DecodeResult<ReadAtResponse> ReadAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<WriteResponse> Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes data to the provided offset.
+ // Does not affect the seek offset.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<WriteAtResponse> WriteAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer);
+
+ // Moves the offset at which the next invocation of `Read()` or `Write()` will
+ // occur.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SeekResponse> Seek(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer);
+
+ // Shrinks the file size to 'length' bytes.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<TruncateResponse> Truncate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<TruncateRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetFlagsResponse> GetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SetFlagsResponse> SetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a buffer representing this file, if there is one, with the
+ // requested access rights.
+ //
+ // `flags` may be any of `VMO_FLAG_*`.
+ //
+ // This method requires following rights:
+ //
+ // - `OPEN_RIGHT_WRITABLE` if `flags` includes `VMO_FLAG_WRITE`.
+ // - `OPEN_RIGHT_READABLE` if `flags` includes `VMO_FLAG_READ` or `VMO_FLAG_EXEC`.
+ static ::fidl::DecodeResult<GetBufferResponse> GetBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = File;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class ReadCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<ReadResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadCompleter = ::fidl::Completer<ReadCompleterBase>;
+
+ virtual void Read(uint64_t count, ReadCompleter::Sync _completer) = 0;
+
+ class ReadAtCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<ReadAtResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadAtCompleter = ::fidl::Completer<ReadAtCompleterBase>;
+
+ virtual void ReadAt(uint64_t count, uint64_t offset, ReadAtCompleter::Sync _completer) = 0;
+
+ class WriteCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint64_t actual);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual);
+ void Reply(::fidl::DecodedMessage<WriteResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteCompleter = ::fidl::Completer<WriteCompleterBase>;
+
+ virtual void Write(::fidl::VectorView<uint8_t> data, WriteCompleter::Sync _completer) = 0;
+
+ class WriteAtCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint64_t actual);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t actual);
+ void Reply(::fidl::DecodedMessage<WriteAtResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteAtCompleter = ::fidl::Completer<WriteAtCompleterBase>;
+
+ virtual void WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset, WriteAtCompleter::Sync _completer) = 0;
+
+ class SeekCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint64_t offset);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t offset);
+ void Reply(::fidl::DecodedMessage<SeekResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SeekCompleter = ::fidl::Completer<SeekCompleterBase>;
+
+ virtual void Seek(int64_t offset, ::llcpp::fuchsia::io::SeekOrigin start, SeekCompleter::Sync _completer) = 0;
+
+ class TruncateCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<TruncateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using TruncateCompleter = ::fidl::Completer<TruncateCompleterBase>;
+
+ virtual void Truncate(uint64_t length, TruncateCompleter::Sync _completer) = 0;
+
+ class GetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<GetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetFlagsCompleter = ::fidl::Completer<GetFlagsCompleterBase>;
+
+ virtual void GetFlags(GetFlagsCompleter::Sync _completer) = 0;
+
+ class SetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetFlagsCompleter = ::fidl::Completer<SetFlagsCompleterBase>;
+
+ virtual void SetFlags(uint32_t flags, SetFlagsCompleter::Sync _completer) = 0;
+
+ class GetBufferCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::mem::Buffer* buffer);
+ void Reply(::fidl::DecodedMessage<GetBufferResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetBufferCompleter = ::fidl::Completer<GetBufferCompleterBase>;
+
+ virtual void GetBuffer(uint32_t flags, GetBufferCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<File::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<File::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<File::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<File::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<File::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<File::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<File::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<File::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<File::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<File::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<File::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<File::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<File::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<File::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<File::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<File::NodeSetFlagsResponse>& _msg);
+ static void ReadRequest(const ::fidl::DecodedMessage<File::ReadRequest>& _msg);
+ static void ReadResponse(const ::fidl::DecodedMessage<File::ReadResponse>& _msg);
+ static void ReadAtRequest(const ::fidl::DecodedMessage<File::ReadAtRequest>& _msg);
+ static void ReadAtResponse(const ::fidl::DecodedMessage<File::ReadAtResponse>& _msg);
+ static void WriteRequest(const ::fidl::DecodedMessage<File::WriteRequest>& _msg);
+ static void WriteResponse(const ::fidl::DecodedMessage<File::WriteResponse>& _msg);
+ static void WriteAtRequest(const ::fidl::DecodedMessage<File::WriteAtRequest>& _msg);
+ static void WriteAtResponse(const ::fidl::DecodedMessage<File::WriteAtResponse>& _msg);
+ static void SeekRequest(const ::fidl::DecodedMessage<File::SeekRequest>& _msg);
+ static void SeekResponse(const ::fidl::DecodedMessage<File::SeekResponse>& _msg);
+ static void TruncateRequest(const ::fidl::DecodedMessage<File::TruncateRequest>& _msg);
+ static void TruncateResponse(const ::fidl::DecodedMessage<File::TruncateResponse>& _msg);
+ static void GetFlagsRequest(const ::fidl::DecodedMessage<File::GetFlagsRequest>& _msg);
+ static void GetFlagsResponse(const ::fidl::DecodedMessage<File::GetFlagsResponse>& _msg);
+ static void SetFlagsRequest(const ::fidl::DecodedMessage<File::SetFlagsRequest>& _msg);
+ static void SetFlagsResponse(const ::fidl::DecodedMessage<File::SetFlagsResponse>& _msg);
+ static void GetBufferRequest(const ::fidl::DecodedMessage<File::GetBufferRequest>& _msg);
+ static void GetBufferResponse(const ::fidl::DecodedMessage<File::GetBufferResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectorySyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectorySyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectorySetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectorySetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryOpenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryUnlinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryUnlinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryReadDirentsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryReadDirentsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRewindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRewindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRenameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryRenameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryLinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryLinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryWatchResponseTable;
+
+// Directory defines a node which is capable of containing other Objects.
+class Directory final {
+ Directory() = delete;
+ public:
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectorySyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectorySetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectorySetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct OpenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ uint32_t mode;
+ ::fidl::StringView path;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryOpenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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;
+ };
+
+ struct UnlinkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryUnlinkResponseTable;
+ 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 UnlinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView path;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryUnlinkRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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 = UnlinkResponse;
+ };
+
+ struct ReadDirentsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::VectorView<uint8_t> dirents;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryReadDirentsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 ReadDirentsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t max_bytes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryReadDirentsRequestTable;
+ 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 = ReadDirentsResponse;
+ };
+
+ struct RewindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryRewindResponseTable;
+ 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 RewindRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::zx::handle token;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryGetTokenResponseTable;
+ 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 GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct RenameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryRenameResponseTable;
+ 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 RenameRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView src;
+ ::zx::handle dst_parent_token;
+ ::fidl::StringView dst;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryRenameRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = RenameResponse;
+ };
+
+ struct LinkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryLinkResponseTable;
+ 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 LinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView src;
+ ::zx::handle dst_parent_token;
+ ::fidl::StringView dst;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryLinkRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = LinkResponse;
+ };
+
+ struct WatchResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryWatchResponseTable;
+ 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 WatchRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t mask;
+ uint32_t options;
+ ::zx::channel watcher;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryWatchRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = WatchResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Open_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Unlink_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path);
+ ~Unlink_Impl() = default;
+ Unlink_Impl(Unlink_Impl&& other) = default;
+ Unlink_Impl& operator=(Unlink_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 ReadDirents_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadDirents_Impl(::zx::unowned_channel _client_end, uint64_t max_bytes);
+ ~ReadDirents_Impl() = default;
+ ReadDirents_Impl(ReadDirents_Impl&& other) = default;
+ ReadDirents_Impl& operator=(ReadDirents_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 Rewind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rewind_Impl(::zx::unowned_channel _client_end);
+ ~Rewind_Impl() = default;
+ Rewind_Impl(Rewind_Impl&& other) = default;
+ Rewind_Impl& operator=(Rewind_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 Rename_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+ ~Rename_Impl() = default;
+ Rename_Impl(Rename_Impl&& other) = default;
+ Rename_Impl& operator=(Rename_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 Link_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+ ~Link_Impl() = default;
+ Link_Impl(Link_Impl&& other) = default;
+ Link_Impl& operator=(Link_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 Watch_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Watch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
+ ~Watch_Impl() = default;
+ Watch_Impl(Watch_Impl&& other) = default;
+ Watch_Impl& operator=(Watch_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Open = Open_Impl;
+ using Unlink = Unlink_Impl<UnlinkResponse>;
+ using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
+ using Rewind = Rewind_Impl<RewindResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using Rename = Rename_Impl<RenameResponse>;
+ using Link = Link_Impl<LinkResponse>;
+ using Watch = Watch_Impl<WatchResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Open_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Unlink_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+ ~Unlink_Impl() = default;
+ Unlink_Impl(Unlink_Impl&& other) = default;
+ Unlink_Impl& operator=(Unlink_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 ReadDirents_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+ ~ReadDirents_Impl() = default;
+ ReadDirents_Impl(ReadDirents_Impl&& other) = default;
+ ReadDirents_Impl& operator=(ReadDirents_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 Rewind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rewind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Rewind_Impl() = default;
+ Rewind_Impl(Rewind_Impl&& other) = default;
+ Rewind_Impl& operator=(Rewind_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 Rename_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+ ~Rename_Impl() = default;
+ Rename_Impl(Rename_Impl&& other) = default;
+ Rename_Impl& operator=(Rename_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 Link_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+ ~Link_Impl() = default;
+ Link_Impl(Link_Impl&& other) = default;
+ Link_Impl& operator=(Link_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 Watch_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+ ~Watch_Impl() = default;
+ Watch_Impl(Watch_Impl&& other) = default;
+ Watch_Impl& operator=(Watch_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Open = Open_Impl;
+ using Unlink = Unlink_Impl<UnlinkResponse>;
+ using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
+ using Rewind = Rewind_Impl<RewindResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using Rename = Rename_Impl<RenameResponse>;
+ using Link = Link_Impl<LinkResponse>;
+ using Watch = Watch_Impl<WatchResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Request is heap-allocated.
+ ResultOf::Open Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Open Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Unlink Unlink(::fidl::StringView path);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Unlink Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::ReadDirents ReadDirents(uint64_t max_bytes);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadDirents ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Rewind Rewind();
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rewind Rewind(::fidl::BytePart _response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Rename Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rename Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Link Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Link Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Watch Watch(uint32_t mask, uint32_t options, ::zx::channel watcher);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Watch Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Request is heap-allocated.
+ static ResultOf::Open Open(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Open Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, uint64_t max_bytes);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Rewind Rewind(::zx::unowned_channel _client_end);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rewind Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Watch Watch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Watch Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ static ::fidl::internal::StatusAndError Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<UnlinkResponse> Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ static ::fidl::DecodeResult<ReadDirentsResponse> ReadDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ static ::fidl::DecodeResult<RewindResponse> Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<RenameResponse> Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<LinkResponse> Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ static ::fidl::DecodeResult<WatchResponse> Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Directory;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ using OpenCompleter = ::fidl::Completer<>;
+
+ virtual void Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object, OpenCompleter::Sync _completer) = 0;
+
+ class UnlinkCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<UnlinkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnlinkCompleter = ::fidl::Completer<UnlinkCompleterBase>;
+
+ virtual void Unlink(::fidl::StringView path, UnlinkCompleter::Sync _completer) = 0;
+
+ class ReadDirentsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents);
+ void Reply(::fidl::DecodedMessage<ReadDirentsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadDirentsCompleter = ::fidl::Completer<ReadDirentsCompleterBase>;
+
+ virtual void ReadDirents(uint64_t max_bytes, ReadDirentsCompleter::Sync _completer) = 0;
+
+ class RewindCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<RewindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RewindCompleter = ::fidl::Completer<RewindCompleterBase>;
+
+ virtual void Rewind(RewindCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::zx::handle token);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class RenameCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<RenameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RenameCompleter = ::fidl::Completer<RenameCompleterBase>;
+
+ virtual void Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, RenameCompleter::Sync _completer) = 0;
+
+ class LinkCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<LinkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LinkCompleter = ::fidl::Completer<LinkCompleterBase>;
+
+ virtual void Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, LinkCompleter::Sync _completer) = 0;
+
+ class WatchCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<WatchResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchCompleter = ::fidl::Completer<WatchCompleterBase>;
+
+ virtual void Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, WatchCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<Directory::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Directory::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<Directory::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Directory::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Directory::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<Directory::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Directory::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Directory::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<Directory::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<Directory::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<Directory::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<Directory::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<Directory::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<Directory::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<Directory::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<Directory::NodeSetFlagsResponse>& _msg);
+ static void OpenRequest(const ::fidl::DecodedMessage<Directory::OpenRequest>& _msg);
+ static void UnlinkRequest(const ::fidl::DecodedMessage<Directory::UnlinkRequest>& _msg);
+ static void UnlinkResponse(const ::fidl::DecodedMessage<Directory::UnlinkResponse>& _msg);
+ static void ReadDirentsRequest(const ::fidl::DecodedMessage<Directory::ReadDirentsRequest>& _msg);
+ static void ReadDirentsResponse(const ::fidl::DecodedMessage<Directory::ReadDirentsResponse>& _msg);
+ static void RewindRequest(const ::fidl::DecodedMessage<Directory::RewindRequest>& _msg);
+ static void RewindResponse(const ::fidl::DecodedMessage<Directory::RewindResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<Directory::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<Directory::GetTokenResponse>& _msg);
+ static void RenameRequest(const ::fidl::DecodedMessage<Directory::RenameRequest>& _msg);
+ static void RenameResponse(const ::fidl::DecodedMessage<Directory::RenameResponse>& _msg);
+ static void LinkRequest(const ::fidl::DecodedMessage<Directory::LinkRequest>& _msg);
+ static void LinkResponse(const ::fidl::DecodedMessage<Directory::LinkResponse>& _msg);
+ static void WatchRequest(const ::fidl::DecodedMessage<Directory::WatchRequest>& _msg);
+ static void WatchResponse(const ::fidl::DecodedMessage<Directory::WatchResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminOpenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnlinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnlinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminReadDirentsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminReadDirentsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRewindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRewindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRenameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminRenameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminLinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminLinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminWatchResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountAndCreateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminMountAndCreateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountNodeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminUnmountNodeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminQueryFilesystemRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminQueryFilesystemResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetDevicePathRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io_DirectoryAdminGetDevicePathResponseTable;
+
+// DirectoryAdmin defines a directory which is capable of handling
+// administrator tasks within the filesystem.
+class DirectoryAdmin final {
+ DirectoryAdmin() = delete;
+ public:
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct OpenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ uint32_t mode;
+ ::fidl::StringView path;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminOpenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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;
+ };
+
+ struct UnlinkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminUnlinkResponseTable;
+ 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 UnlinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView path;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminUnlinkRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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 = UnlinkResponse;
+ };
+
+ struct ReadDirentsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::VectorView<uint8_t> dirents;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminReadDirentsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ 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 ReadDirentsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t max_bytes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminReadDirentsRequestTable;
+ 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 = ReadDirentsResponse;
+ };
+
+ struct RewindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminRewindResponseTable;
+ 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 RewindRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::zx::handle token;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminGetTokenResponseTable;
+ 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 GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct RenameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminRenameResponseTable;
+ 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 RenameRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView src;
+ ::zx::handle dst_parent_token;
+ ::fidl::StringView dst;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminRenameRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = RenameResponse;
+ };
+
+ struct LinkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminLinkResponseTable;
+ 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 LinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView src;
+ ::zx::handle dst_parent_token;
+ ::fidl::StringView dst;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminLinkRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = LinkResponse;
+ };
+
+ struct WatchResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminWatchResponseTable;
+ 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 WatchRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t mask;
+ uint32_t options;
+ ::zx::channel watcher;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminWatchRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = WatchResponse;
+ };
+
+ struct MountResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminMountResponseTable;
+ 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 MountRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel remote;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminMountRequestTable;
+ 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 = MountResponse;
+ };
+
+ struct MountAndCreateResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminMountAndCreateResponseTable;
+ 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 MountAndCreateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel remote;
+ ::fidl::StringView name;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminMountAndCreateRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 256;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 256;
+ 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 = MountAndCreateResponse;
+ };
+
+ struct UnmountResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminUnmountResponseTable;
+ 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 UnmountRequest = ::fidl::AnyZeroArgMessage;
+
+ struct UnmountNodeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::zx::channel remote;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminUnmountNodeResponseTable;
+ 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 UnmountNodeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct QueryFilesystemResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::FilesystemInfo* info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminQueryFilesystemResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 96;
+ 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 QueryFilesystemRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetDevicePathResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::fidl::StringView path;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io_DirectoryAdminGetDevicePathResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ 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 GetDevicePathRequest = ::fidl::AnyZeroArgMessage;
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Open_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Unlink_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path);
+ ~Unlink_Impl() = default;
+ Unlink_Impl(Unlink_Impl&& other) = default;
+ Unlink_Impl& operator=(Unlink_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 ReadDirents_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadDirents_Impl(::zx::unowned_channel _client_end, uint64_t max_bytes);
+ ~ReadDirents_Impl() = default;
+ ReadDirents_Impl(ReadDirents_Impl&& other) = default;
+ ReadDirents_Impl& operator=(ReadDirents_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 Rewind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rewind_Impl(::zx::unowned_channel _client_end);
+ ~Rewind_Impl() = default;
+ Rewind_Impl(Rewind_Impl&& other) = default;
+ Rewind_Impl& operator=(Rewind_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 Rename_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+ ~Rename_Impl() = default;
+ Rename_Impl(Rename_Impl&& other) = default;
+ Rename_Impl& operator=(Rename_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 Link_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+ ~Link_Impl() = default;
+ Link_Impl(Link_Impl&& other) = default;
+ Link_Impl& operator=(Link_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 Watch_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Watch_Impl(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
+ ~Watch_Impl() = default;
+ Watch_Impl(Watch_Impl&& other) = default;
+ Watch_Impl& operator=(Watch_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 Mount_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Mount_Impl(::zx::unowned_channel _client_end, ::zx::channel remote);
+ ~Mount_Impl() = default;
+ Mount_Impl(Mount_Impl&& other) = default;
+ Mount_Impl& operator=(Mount_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 MountAndCreate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ MountAndCreate_Impl(::zx::unowned_channel _client_end, ::zx::channel remote, ::fidl::StringView name, uint32_t flags);
+ ~MountAndCreate_Impl() = default;
+ MountAndCreate_Impl(MountAndCreate_Impl&& other) = default;
+ MountAndCreate_Impl& operator=(MountAndCreate_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 Unmount_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Unmount_Impl(::zx::unowned_channel _client_end);
+ ~Unmount_Impl() = default;
+ Unmount_Impl(Unmount_Impl&& other) = default;
+ Unmount_Impl& operator=(Unmount_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 UnmountNode_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UnmountNode_Impl(::zx::unowned_channel _client_end);
+ ~UnmountNode_Impl() = default;
+ UnmountNode_Impl(UnmountNode_Impl&& other) = default;
+ UnmountNode_Impl& operator=(UnmountNode_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 QueryFilesystem_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ QueryFilesystem_Impl(::zx::unowned_channel _client_end);
+ ~QueryFilesystem_Impl() = default;
+ QueryFilesystem_Impl(QueryFilesystem_Impl&& other) = default;
+ QueryFilesystem_Impl& operator=(QueryFilesystem_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 GetDevicePath_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetDevicePath_Impl(::zx::unowned_channel _client_end);
+ ~GetDevicePath_Impl() = default;
+ GetDevicePath_Impl(GetDevicePath_Impl&& other) = default;
+ GetDevicePath_Impl& operator=(GetDevicePath_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Open = Open_Impl;
+ using Unlink = Unlink_Impl<UnlinkResponse>;
+ using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
+ using Rewind = Rewind_Impl<RewindResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using Rename = Rename_Impl<RenameResponse>;
+ using Link = Link_Impl<LinkResponse>;
+ using Watch = Watch_Impl<WatchResponse>;
+ using Mount = Mount_Impl<MountResponse>;
+ using MountAndCreate = MountAndCreate_Impl<MountAndCreateResponse>;
+ using Unmount = Unmount_Impl<UnmountResponse>;
+ using UnmountNode = UnmountNode_Impl<UnmountNodeResponse>;
+ using QueryFilesystem = QueryFilesystem_Impl<QueryFilesystemResponse>;
+ using GetDevicePath = GetDevicePath_Impl<GetDevicePathResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Open_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Unlink_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+ ~Unlink_Impl() = default;
+ Unlink_Impl(Unlink_Impl&& other) = default;
+ Unlink_Impl& operator=(Unlink_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 ReadDirents_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+ ~ReadDirents_Impl() = default;
+ ReadDirents_Impl(ReadDirents_Impl&& other) = default;
+ ReadDirents_Impl& operator=(ReadDirents_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 Rewind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rewind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Rewind_Impl() = default;
+ Rewind_Impl(Rewind_Impl&& other) = default;
+ Rewind_Impl& operator=(Rewind_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 Rename_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+ ~Rename_Impl() = default;
+ Rename_Impl(Rename_Impl&& other) = default;
+ Rename_Impl& operator=(Rename_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 Link_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+ ~Link_Impl() = default;
+ Link_Impl(Link_Impl&& other) = default;
+ Link_Impl& operator=(Link_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 Watch_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+ ~Watch_Impl() = default;
+ Watch_Impl(Watch_Impl&& other) = default;
+ Watch_Impl& operator=(Watch_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 Mount_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Mount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer);
+ ~Mount_Impl() = default;
+ Mount_Impl(Mount_Impl&& other) = default;
+ Mount_Impl& operator=(Mount_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 MountAndCreate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ MountAndCreate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~MountAndCreate_Impl() = default;
+ MountAndCreate_Impl(MountAndCreate_Impl&& other) = default;
+ MountAndCreate_Impl& operator=(MountAndCreate_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 Unmount_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Unmount_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Unmount_Impl() = default;
+ Unmount_Impl(Unmount_Impl&& other) = default;
+ Unmount_Impl& operator=(Unmount_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 UnmountNode_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UnmountNode_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~UnmountNode_Impl() = default;
+ UnmountNode_Impl(UnmountNode_Impl&& other) = default;
+ UnmountNode_Impl& operator=(UnmountNode_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 QueryFilesystem_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ QueryFilesystem_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~QueryFilesystem_Impl() = default;
+ QueryFilesystem_Impl(QueryFilesystem_Impl&& other) = default;
+ QueryFilesystem_Impl& operator=(QueryFilesystem_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 GetDevicePath_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetDevicePath_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetDevicePath_Impl() = default;
+ GetDevicePath_Impl(GetDevicePath_Impl&& other) = default;
+ GetDevicePath_Impl& operator=(GetDevicePath_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Open = Open_Impl;
+ using Unlink = Unlink_Impl<UnlinkResponse>;
+ using ReadDirents = ReadDirents_Impl<ReadDirentsResponse>;
+ using Rewind = Rewind_Impl<RewindResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using Rename = Rename_Impl<RenameResponse>;
+ using Link = Link_Impl<LinkResponse>;
+ using Watch = Watch_Impl<WatchResponse>;
+ using Mount = Mount_Impl<MountResponse>;
+ using MountAndCreate = MountAndCreate_Impl<MountAndCreateResponse>;
+ using Unmount = Unmount_Impl<UnmountResponse>;
+ using UnmountNode = UnmountNode_Impl<UnmountNodeResponse>;
+ using QueryFilesystem = QueryFilesystem_Impl<QueryFilesystemResponse>;
+ using GetDevicePath = GetDevicePath_Impl<GetDevicePathResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Request is heap-allocated.
+ ResultOf::Open Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Open Open(::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Unlink Unlink(::fidl::StringView path);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Unlink Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::ReadDirents ReadDirents(uint64_t max_bytes);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadDirents ReadDirents(::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Rewind Rewind();
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rewind Rewind(::fidl::BytePart _response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Rename Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rename Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Link Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Link Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Watch Watch(uint32_t mask, uint32_t options, ::zx::channel watcher);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Watch Watch(::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+
+ // Mount a channel representing a remote filesystem onto this directory.
+ // All future requests to this node will be forwarded to the remote filesystem.
+ // To re-open a node without forwarding to the remote target, the node
+ // should be opened with `OPEN_FLAG_NO_REMOTE`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Mount Mount(::zx::channel remote);
+
+ // Mount a channel representing a remote filesystem onto this directory.
+ // All future requests to this node will be forwarded to the remote filesystem.
+ // To re-open a node without forwarding to the remote target, the node
+ // should be opened with `OPEN_FLAG_NO_REMOTE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Mount Mount(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer);
+
+ // Atomically create a directory with a provided path, and mount the
+ // remote handle to the newly created directory.
+ // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::MountAndCreate MountAndCreate(::zx::channel remote, ::fidl::StringView name, uint32_t flags);
+
+ // Atomically create a directory with a provided path, and mount the
+ // remote handle to the newly created directory.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::MountAndCreate MountAndCreate(::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Unmount this filesystem. After this function returns successfully,
+ // all connections to the filesystem will be terminated.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Unmount Unmount();
+
+ // Unmount this filesystem. After this function returns successfully,
+ // all connections to the filesystem will be terminated.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Unmount Unmount(::fidl::BytePart _response_buffer);
+
+ // Detach a node which was previously attached to this directory
+ // with Mount.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UnmountNode UnmountNode();
+
+ // Detach a node which was previously attached to this directory
+ // with Mount.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UnmountNode UnmountNode(::fidl::BytePart _response_buffer);
+
+ // Query the filesystem for filesystem-specific information.
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::QueryFilesystem QueryFilesystem();
+
+ // Query the filesystem for filesystem-specific information.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::QueryFilesystem QueryFilesystem(::fidl::BytePart _response_buffer);
+
+ // Acquire the path to the device backing this filesystem, if there is one.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetDevicePath GetDevicePath();
+
+ // Acquire the path to the device backing this filesystem, if there is one.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetDevicePath GetDevicePath(::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Request is heap-allocated.
+ static ResultOf::Open Open(::zx::unowned_channel _client_end, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Open Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, uint64_t max_bytes);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadDirents ReadDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t max_bytes, ::fidl::BytePart _response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Rewind Rewind(::zx::unowned_channel _client_end);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rewind Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Watch Watch(::zx::unowned_channel _client_end, uint32_t mask, uint32_t options, ::zx::channel watcher);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Watch Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t mask, uint32_t options, ::zx::channel watcher, ::fidl::BytePart _response_buffer);
+
+ // Mount a channel representing a remote filesystem onto this directory.
+ // All future requests to this node will be forwarded to the remote filesystem.
+ // To re-open a node without forwarding to the remote target, the node
+ // should be opened with `OPEN_FLAG_NO_REMOTE`.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Mount Mount(::zx::unowned_channel _client_end, ::zx::channel remote);
+
+ // Mount a channel representing a remote filesystem onto this directory.
+ // All future requests to this node will be forwarded to the remote filesystem.
+ // To re-open a node without forwarding to the remote target, the node
+ // should be opened with `OPEN_FLAG_NO_REMOTE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Mount Mount(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::BytePart _response_buffer);
+
+ // Atomically create a directory with a provided path, and mount the
+ // remote handle to the newly created directory.
+ // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::MountAndCreate MountAndCreate(::zx::unowned_channel _client_end, ::zx::channel remote, ::fidl::StringView name, uint32_t flags);
+
+ // Atomically create a directory with a provided path, and mount the
+ // remote handle to the newly created directory.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::MountAndCreate MountAndCreate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel remote, ::fidl::StringView name, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Unmount this filesystem. After this function returns successfully,
+ // all connections to the filesystem will be terminated.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Unmount Unmount(::zx::unowned_channel _client_end);
+
+ // Unmount this filesystem. After this function returns successfully,
+ // all connections to the filesystem will be terminated.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Unmount Unmount(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Detach a node which was previously attached to this directory
+ // with Mount.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UnmountNode UnmountNode(::zx::unowned_channel _client_end);
+
+ // Detach a node which was previously attached to this directory
+ // with Mount.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UnmountNode UnmountNode(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Query the filesystem for filesystem-specific information.
+ // Allocates 144 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::QueryFilesystem QueryFilesystem(::zx::unowned_channel _client_end);
+
+ // Query the filesystem for filesystem-specific information.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::QueryFilesystem QueryFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquire the path to the device backing this filesystem, if there is one.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetDevicePath GetDevicePath(::zx::unowned_channel _client_end);
+
+ // Acquire the path to the device backing this filesystem, if there is one.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetDevicePath GetDevicePath(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Opens a new object relative to this directory object.
+ //
+ // `path` may contain multiple segments, separated by "/" characters,
+ // and should never be empty; i.e., "" is an invalid path.
+ //
+ // `flags` may be any of the `OPEN_FLAG_*` and `OPEN_RIGHT_*` values, bitwise ORed together.
+ // The `OPEN_FLAG_DESCRIBE` flag may cause an `OnOpen` event to be transmitted
+ // on the `object` handle, indicating the type of object opened.
+ //
+ // If an unknown value is sent for either flags or mode, the connection should
+ // be closed.
+ //
+ // `OPEN_RIGHT_*` flags provided in `flags` will restrict access rights on
+ // the `object` channel which will be connected to the opened entity.
+ //
+ // Rights are never increased. When you open a nested entity within a directory, you may only
+ // request the same rights as what the directory connection already has, or a subset of those.
+ // Exceeding those rights causes an access denied error to be transmitted in the
+ // `OnOpen` event if applicable, and the `object` connection closed.
+ //
+ // The caller must specify either one or more of the `OPEN_RIGHT_*` flags, or
+ // the `OPEN_FLAG_NODE_REFERENCE` flag.
+ static ::fidl::internal::StatusAndError Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params);
+
+ // Detaches an object from this directory object.
+ //
+ // The underlying object may or may not be deleted after this method
+ // completes: although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are removed.
+ //
+ // If a directory is unlinked while it still has an open reference,
+ // it must become read-only, preventing new entries from being created
+ // until all references close and the directory is destroyed.
+ //
+ // `path` identifies the file which should be detached.
+ // If `path` contains multiple segments, separated by "/" characters,
+ // then the directory is traversed, one segment at a time, relative to the
+ // originally accessed Directory.
+ //
+ // Returns:
+ // `ZX_ERR_ACCESS_DENIED` if the connection (or the underlying filesystem) does not
+ // allow writable access.
+ // `ZX_ERR_INVALID_ARGS` if `path` contains ".." segments.
+ // `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point, containing a remote channel.
+ // `ZX_ERR_UNAVAILABLE` if `path` is ".".
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<UnlinkResponse> Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads a collection of variably sized dirents into a buffer.
+ // The number of dirents in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to ReadDirents.
+ //
+ // These dirents are of the form:
+ // ```
+ // struct dirent {
+ // // Describes the inode of the entry.
+ // uint64 ino;
+ // // Describes the length of the dirent name in bytes.
+ // uint8 size;
+ // // Describes the type of the entry. Aligned with the
+ // // POSIX d_type values. Use `DIRENT_TYPE_*` constants.
+ // uint8 type;
+ // // Unterminated name of entry.
+ // char name[0];
+ // }
+ // ```
+ //
+ // This method does not require any rights, since one could always probe for
+ // directory contents by triggering name conflicts during file creation.
+ static ::fidl::DecodeResult<ReadDirentsResponse> ReadDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadDirentsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Resets the directory seek offset.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ static ::fidl::DecodeResult<RewindResponse> Rewind(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires a token to a Directory which can be used to identify
+ // access to it at a later point in time.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Renames an object named src to the name dst, in a directory represented by token.
+ //
+ // `src/dst` must be resolved object names. Including "/" in any position
+ // other than the end of the string will return `ZX_ERR_INVALID_ARGS`.
+ // Returning "/" at the end of either string implies that it must be a
+ // directory, or else `ZX_ERR_NOT_DIR` should be returned.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<RenameResponse> Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer);
+
+ // Creates a link to an object named src by the name dst, within a directory represented by
+ // token.
+ //
+ // `src` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // `dst` must be a resolved object name. Including "/" in the string will
+ // return `ZX_ERR_INVALID_ARGS`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<LinkResponse> Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Watches a directory, receiving events of added messages on the
+ // watcher request channel.
+ //
+ // The `watcher` handle will send messages of the form:
+ // ```
+ // struct {
+ // uint8 event;
+ // uint8 len;
+ // char name[];
+ // };
+ // ```
+ // Where names are NOT null-terminated.
+ //
+ // This API is unstable; in the future, watcher will be a `DirectoryWatcher` client.
+ //
+ // Mask specifies a bitmask of events to observe.
+ // Options must be zero; it is reserved.
+ //
+ // This method does not require any rights, similar to ReadDirents.
+ static ::fidl::DecodeResult<WatchResponse> Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params, ::fidl::BytePart response_buffer);
+
+ // Mount a channel representing a remote filesystem onto this directory.
+ // All future requests to this node will be forwarded to the remote filesystem.
+ // To re-open a node without forwarding to the remote target, the node
+ // should be opened with `OPEN_FLAG_NO_REMOTE`.
+ static ::fidl::DecodeResult<MountResponse> Mount(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MountRequest> params, ::fidl::BytePart response_buffer);
+
+ // Atomically create a directory with a provided path, and mount the
+ // remote handle to the newly created directory.
+ static ::fidl::DecodeResult<MountAndCreateResponse> MountAndCreate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<MountAndCreateRequest> params, ::fidl::BytePart response_buffer);
+
+ // Unmount this filesystem. After this function returns successfully,
+ // all connections to the filesystem will be terminated.
+ static ::fidl::DecodeResult<UnmountResponse> Unmount(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Detach a node which was previously attached to this directory
+ // with Mount.
+ static ::fidl::DecodeResult<UnmountNodeResponse> UnmountNode(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Query the filesystem for filesystem-specific information.
+ static ::fidl::DecodeResult<QueryFilesystemResponse> QueryFilesystem(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquire the path to the device backing this filesystem, if there is one.
+ static ::fidl::DecodeResult<GetDevicePathResponse> GetDevicePath(::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 = DirectoryAdmin;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ using OpenCompleter = ::fidl::Completer<>;
+
+ virtual void Open(uint32_t flags, uint32_t mode, ::fidl::StringView path, ::zx::channel object, OpenCompleter::Sync _completer) = 0;
+
+ class UnlinkCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<UnlinkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnlinkCompleter = ::fidl::Completer<UnlinkCompleterBase>;
+
+ virtual void Unlink(::fidl::StringView path, UnlinkCompleter::Sync _completer) = 0;
+
+ class ReadDirentsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::VectorView<uint8_t> dirents);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::VectorView<uint8_t> dirents);
+ void Reply(::fidl::DecodedMessage<ReadDirentsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadDirentsCompleter = ::fidl::Completer<ReadDirentsCompleterBase>;
+
+ virtual void ReadDirents(uint64_t max_bytes, ReadDirentsCompleter::Sync _completer) = 0;
+
+ class RewindCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<RewindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RewindCompleter = ::fidl::Completer<RewindCompleterBase>;
+
+ virtual void Rewind(RewindCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::zx::handle token);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class RenameCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<RenameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RenameCompleter = ::fidl::Completer<RenameCompleterBase>;
+
+ virtual void Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, RenameCompleter::Sync _completer) = 0;
+
+ class LinkCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<LinkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LinkCompleter = ::fidl::Completer<LinkCompleterBase>;
+
+ virtual void Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, LinkCompleter::Sync _completer) = 0;
+
+ class WatchCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<WatchResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WatchCompleter = ::fidl::Completer<WatchCompleterBase>;
+
+ virtual void Watch(uint32_t mask, uint32_t options, ::zx::channel watcher, WatchCompleter::Sync _completer) = 0;
+
+ class MountCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<MountResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using MountCompleter = ::fidl::Completer<MountCompleterBase>;
+
+ virtual void Mount(::zx::channel remote, MountCompleter::Sync _completer) = 0;
+
+ class MountAndCreateCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<MountAndCreateResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using MountAndCreateCompleter = ::fidl::Completer<MountAndCreateCompleterBase>;
+
+ virtual void MountAndCreate(::zx::channel remote, ::fidl::StringView name, uint32_t flags, MountAndCreateCompleter::Sync _completer) = 0;
+
+ class UnmountCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<UnmountResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnmountCompleter = ::fidl::Completer<UnmountCompleterBase>;
+
+ virtual void Unmount(UnmountCompleter::Sync _completer) = 0;
+
+ class UnmountNodeCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::zx::channel remote);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::zx::channel remote);
+ void Reply(::fidl::DecodedMessage<UnmountNodeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnmountNodeCompleter = ::fidl::Completer<UnmountNodeCompleterBase>;
+
+ virtual void UnmountNode(UnmountNodeCompleter::Sync _completer) = 0;
+
+ class QueryFilesystemCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::FilesystemInfo* info);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::FilesystemInfo* info);
+ void Reply(::fidl::DecodedMessage<QueryFilesystemResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using QueryFilesystemCompleter = ::fidl::Completer<QueryFilesystemCompleterBase>;
+
+ virtual void QueryFilesystem(QueryFilesystemCompleter::Sync _completer) = 0;
+
+ class GetDevicePathCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::fidl::StringView path);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::fidl::StringView path);
+ void Reply(::fidl::DecodedMessage<GetDevicePathResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetDevicePathCompleter = ::fidl::Completer<GetDevicePathCompleterBase>;
+
+ virtual void GetDevicePath(GetDevicePathCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<DirectoryAdmin::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<DirectoryAdmin::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<DirectoryAdmin::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<DirectoryAdmin::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<DirectoryAdmin::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<DirectoryAdmin::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<DirectoryAdmin::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<DirectoryAdmin::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<DirectoryAdmin::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<DirectoryAdmin::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::NodeSetFlagsResponse>& _msg);
+ static void OpenRequest(const ::fidl::DecodedMessage<DirectoryAdmin::OpenRequest>& _msg);
+ static void UnlinkRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnlinkRequest>& _msg);
+ static void UnlinkResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnlinkResponse>& _msg);
+ static void ReadDirentsRequest(const ::fidl::DecodedMessage<DirectoryAdmin::ReadDirentsRequest>& _msg);
+ static void ReadDirentsResponse(const ::fidl::DecodedMessage<DirectoryAdmin::ReadDirentsResponse>& _msg);
+ static void RewindRequest(const ::fidl::DecodedMessage<DirectoryAdmin::RewindRequest>& _msg);
+ static void RewindResponse(const ::fidl::DecodedMessage<DirectoryAdmin::RewindResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetTokenResponse>& _msg);
+ static void RenameRequest(const ::fidl::DecodedMessage<DirectoryAdmin::RenameRequest>& _msg);
+ static void RenameResponse(const ::fidl::DecodedMessage<DirectoryAdmin::RenameResponse>& _msg);
+ static void LinkRequest(const ::fidl::DecodedMessage<DirectoryAdmin::LinkRequest>& _msg);
+ static void LinkResponse(const ::fidl::DecodedMessage<DirectoryAdmin::LinkResponse>& _msg);
+ static void WatchRequest(const ::fidl::DecodedMessage<DirectoryAdmin::WatchRequest>& _msg);
+ static void WatchResponse(const ::fidl::DecodedMessage<DirectoryAdmin::WatchResponse>& _msg);
+ static void MountRequest(const ::fidl::DecodedMessage<DirectoryAdmin::MountRequest>& _msg);
+ static void MountResponse(const ::fidl::DecodedMessage<DirectoryAdmin::MountResponse>& _msg);
+ static void MountAndCreateRequest(const ::fidl::DecodedMessage<DirectoryAdmin::MountAndCreateRequest>& _msg);
+ static void MountAndCreateResponse(const ::fidl::DecodedMessage<DirectoryAdmin::MountAndCreateResponse>& _msg);
+ static void UnmountRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountRequest>& _msg);
+ static void UnmountResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountResponse>& _msg);
+ static void UnmountNodeRequest(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountNodeRequest>& _msg);
+ static void UnmountNodeResponse(const ::fidl::DecodedMessage<DirectoryAdmin::UnmountNodeResponse>& _msg);
+ static void QueryFilesystemRequest(const ::fidl::DecodedMessage<DirectoryAdmin::QueryFilesystemRequest>& _msg);
+ static void QueryFilesystemResponse(const ::fidl::DecodedMessage<DirectoryAdmin::QueryFilesystemResponse>& _msg);
+ static void GetDevicePathRequest(const ::fidl::DecodedMessage<DirectoryAdmin::GetDevicePathRequest>& _msg);
+ static void GetDevicePathResponse(const ::fidl::DecodedMessage<DirectoryAdmin::GetDevicePathResponse>& _msg);
+ };
+};
+
+// A dirent with an unknown type.
+constexpr uint8_t DIRENT_TYPE_UNKNOWN = 0u;
+
+// A dirent representing a socket object.
+constexpr uint8_t DIRENT_TYPE_SOCKET = 12u;
+
+// A dirent representing a service object.
+constexpr uint8_t DIRENT_TYPE_SERVICE = 16u;
+
+// A dirent representing a file object.
+constexpr uint8_t DIRENT_TYPE_FILE = 8u;
+
+// A dirent representing a directory object.
+constexpr uint8_t DIRENT_TYPE_DIRECTORY = 4u;
+
+// A dirent representing a block device object.
+constexpr uint8_t DIRENT_TYPE_BLOCK_DEVICE = 6u;
+
+// Indicates the device is ready for writing.
+constexpr uint32_t DEVICE_SIGNAL_WRITABLE = 67108864u;
+
+// Indicates the device is ready for reading.
+constexpr uint32_t DEVICE_SIGNAL_READABLE = 16777216u;
+
+// Indicates an out-of-band state transition has occurred.
+constexpr uint32_t DEVICE_SIGNAL_OOB = 33554432u;
+
+// Indicates the device has hung up on the current connection.
+constexpr uint32_t DEVICE_SIGNAL_HANGUP = 268435456u;
+
+// Indicates the device has encountered an error state.
+constexpr uint32_t DEVICE_SIGNAL_ERROR = 134217728u;
+
+// When used during clone, the new connection inherits the rights on the source connection,
+// regardless if it is a file or directory. Otherwise, clone attempts to use the requested rights.
+// It is invalid to pass any of the `OPEN_RIGHT_*` flags together with `CLONE_FLAG_SAME_RIGHTS`.
+constexpr uint32_t CLONE_FLAG_SAME_RIGHTS = 67108864u;
+
+} // namespace io
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::WatchedEvent> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::WatchedEvent>);
+static_assert(offsetof(::llcpp::fuchsia::io::WatchedEvent, event) == 0);
+static_assert(offsetof(::llcpp::fuchsia::io::WatchedEvent, len) == 1);
+static_assert(offsetof(::llcpp::fuchsia::io::WatchedEvent, name) == 8);
+static_assert(sizeof(::llcpp::fuchsia::io::WatchedEvent) == ::llcpp::fuchsia::io::WatchedEvent::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Vmofile> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Vmofile>);
+static_assert(offsetof(::llcpp::fuchsia::io::Vmofile, vmo) == 0);
+static_assert(offsetof(::llcpp::fuchsia::io::Vmofile, offset) == 8);
+static_assert(offsetof(::llcpp::fuchsia::io::Vmofile, length) == 16);
+static_assert(sizeof(::llcpp::fuchsia::io::Vmofile) == ::llcpp::fuchsia::io::Vmofile::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Tty> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Tty>);
+static_assert(offsetof(::llcpp::fuchsia::io::Tty, event) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::Tty) == ::llcpp::fuchsia::io::Tty::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::StreamSocket> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::StreamSocket>);
+static_assert(offsetof(::llcpp::fuchsia::io::StreamSocket, socket) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::StreamSocket) == ::llcpp::fuchsia::io::StreamSocket::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest)
+ == ::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryWatcher::OnEventRequest, events) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Socket> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Socket>);
+static_assert(offsetof(::llcpp::fuchsia::io::Socket, socket) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::Socket) == ::llcpp::fuchsia::io::Socket::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Service> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Service>);
+static_assert(offsetof(::llcpp::fuchsia::io::Service, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::Service) == ::llcpp::fuchsia::io::Service::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Pipe> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Pipe>);
+static_assert(offsetof(::llcpp::fuchsia::io::Pipe, socket) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::Pipe) == ::llcpp::fuchsia::io::Pipe::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::NodeAttributes> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::NodeAttributes>);
+static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, mode) == 0);
+static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, id) == 8);
+static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, content_size) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, storage_size) == 24);
+static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, link_count) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, creation_time) == 40);
+static_assert(offsetof(::llcpp::fuchsia::io::NodeAttributes, modification_time) == 48);
+static_assert(sizeof(::llcpp::fuchsia::io::NodeAttributes) == ::llcpp::fuchsia::io::NodeAttributes::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::FilesystemInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::FilesystemInfo>);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, total_bytes) == 0);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, used_bytes) == 8);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, total_nodes) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, used_nodes) == 24);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, free_shared_pool_bytes) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, fs_id) == 40);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, block_size) == 48);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, max_filename_size) == 52);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, fs_type) == 56);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, padding) == 60);
+static_assert(offsetof(::llcpp::fuchsia::io::FilesystemInfo, name) == 64);
+static_assert(sizeof(::llcpp::fuchsia::io::FilesystemInfo) == ::llcpp::fuchsia::io::FilesystemInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::FileObject> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::FileObject>);
+static_assert(offsetof(::llcpp::fuchsia::io::FileObject, event) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::FileObject) == ::llcpp::fuchsia::io::FileObject::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryObject> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::DirectoryObject>);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryObject, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryObject) == ::llcpp::fuchsia::io::DirectoryObject::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Device> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::Device>);
+static_assert(offsetof(::llcpp::fuchsia::io::Device, event) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::Device) == ::llcpp::fuchsia::io::Device::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DatagramSocket> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::DatagramSocket>);
+static_assert(offsetof(::llcpp::fuchsia::io::DatagramSocket, event) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io::DatagramSocket) == ::llcpp::fuchsia::io::DatagramSocket::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::NodeInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io::NodeInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::CloneRequest)
+ == ::llcpp::fuchsia::io::Node::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::CloseResponse)
+ == ::llcpp::fuchsia::io::Node::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::DescribeResponse)
+ == ::llcpp::fuchsia::io::Node::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::OnOpenResponse)
+ == ::llcpp::fuchsia::io::Node::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::SyncResponse)
+ == ::llcpp::fuchsia::io::Node::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::GetAttrResponse)
+ == ::llcpp::fuchsia::io::Node::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::SetAttrRequest)
+ == ::llcpp::fuchsia::io::Node::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::SetAttrResponse)
+ == ::llcpp::fuchsia::io::Node::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::io::Node::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::io::Node::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Node::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Node::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Node::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::io::Node::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Node::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::CloneRequest)
+ == ::llcpp::fuchsia::io::File::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::CloseResponse)
+ == ::llcpp::fuchsia::io::File::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::DescribeResponse)
+ == ::llcpp::fuchsia::io::File::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::OnOpenResponse)
+ == ::llcpp::fuchsia::io::File::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::SyncResponse)
+ == ::llcpp::fuchsia::io::File::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::GetAttrResponse)
+ == ::llcpp::fuchsia::io::File::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::SetAttrRequest)
+ == ::llcpp::fuchsia::io::File::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::SetAttrResponse)
+ == ::llcpp::fuchsia::io::File::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::io::File::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::io::File::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::io::File::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::ReadRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::ReadRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::ReadRequest)
+ == ::llcpp::fuchsia::io::File::ReadRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::ReadRequest, count) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::ReadResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::ReadResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::ReadResponse)
+ == ::llcpp::fuchsia::io::File::ReadResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::ReadResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::ReadResponse, data) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::ReadAtRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::ReadAtRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::ReadAtRequest)
+ == ::llcpp::fuchsia::io::File::ReadAtRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::ReadAtRequest, count) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::ReadAtRequest, offset) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::ReadAtResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::ReadAtResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::ReadAtResponse)
+ == ::llcpp::fuchsia::io::File::ReadAtResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::ReadAtResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::ReadAtResponse, data) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::WriteRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::WriteRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::WriteRequest)
+ == ::llcpp::fuchsia::io::File::WriteRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::WriteRequest, data) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::WriteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::WriteResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::WriteResponse)
+ == ::llcpp::fuchsia::io::File::WriteResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::WriteResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::WriteResponse, actual) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::WriteAtRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::WriteAtRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::WriteAtRequest)
+ == ::llcpp::fuchsia::io::File::WriteAtRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::WriteAtRequest, data) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::WriteAtRequest, offset) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::WriteAtResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::WriteAtResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::WriteAtResponse)
+ == ::llcpp::fuchsia::io::File::WriteAtResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::WriteAtResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::WriteAtResponse, actual) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::SeekRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::SeekRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::SeekRequest)
+ == ::llcpp::fuchsia::io::File::SeekRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SeekRequest, offset) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SeekRequest, start) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::SeekResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::SeekResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::SeekResponse)
+ == ::llcpp::fuchsia::io::File::SeekResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SeekResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SeekResponse, offset) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::TruncateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::TruncateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::TruncateRequest)
+ == ::llcpp::fuchsia::io::File::TruncateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::TruncateRequest, length) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::TruncateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::TruncateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::TruncateResponse)
+ == ::llcpp::fuchsia::io::File::TruncateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::TruncateResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::GetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::GetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::GetFlagsResponse)
+ == ::llcpp::fuchsia::io::File::GetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::GetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::GetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::SetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::SetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::SetFlagsRequest)
+ == ::llcpp::fuchsia::io::File::SetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::SetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::SetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::SetFlagsResponse)
+ == ::llcpp::fuchsia::io::File::SetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::SetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::GetBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::GetBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::GetBufferRequest)
+ == ::llcpp::fuchsia::io::File::GetBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::GetBufferRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::File::GetBufferResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::File::GetBufferResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::File::GetBufferResponse)
+ == ::llcpp::fuchsia::io::File::GetBufferResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::File::GetBufferResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::File::GetBufferResponse, buffer) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::CloneRequest)
+ == ::llcpp::fuchsia::io::Directory::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::CloseResponse)
+ == ::llcpp::fuchsia::io::Directory::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::DescribeResponse)
+ == ::llcpp::fuchsia::io::Directory::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::OnOpenResponse)
+ == ::llcpp::fuchsia::io::Directory::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::SyncResponse)
+ == ::llcpp::fuchsia::io::Directory::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::GetAttrResponse)
+ == ::llcpp::fuchsia::io::Directory::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::SetAttrRequest)
+ == ::llcpp::fuchsia::io::Directory::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::SetAttrResponse)
+ == ::llcpp::fuchsia::io::Directory::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::OpenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::OpenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::OpenRequest)
+ == ::llcpp::fuchsia::io::Directory::OpenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::OpenRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::OpenRequest, mode) == 20);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::OpenRequest, path) == 24);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::OpenRequest, object) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::UnlinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::UnlinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::UnlinkRequest)
+ == ::llcpp::fuchsia::io::Directory::UnlinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::UnlinkRequest, path) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::UnlinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::UnlinkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::UnlinkResponse)
+ == ::llcpp::fuchsia::io::Directory::UnlinkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::UnlinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::ReadDirentsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::ReadDirentsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::ReadDirentsRequest)
+ == ::llcpp::fuchsia::io::Directory::ReadDirentsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::ReadDirentsRequest, max_bytes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::ReadDirentsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::ReadDirentsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::ReadDirentsResponse)
+ == ::llcpp::fuchsia::io::Directory::ReadDirentsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::ReadDirentsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::ReadDirentsResponse, dirents) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::RewindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::RewindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::RewindResponse)
+ == ::llcpp::fuchsia::io::Directory::RewindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::RewindResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::GetTokenResponse)
+ == ::llcpp::fuchsia::io::Directory::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::GetTokenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::GetTokenResponse, token) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::RenameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::RenameRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::RenameRequest)
+ == ::llcpp::fuchsia::io::Directory::RenameRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::RenameRequest, src) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::RenameRequest, dst_parent_token) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::RenameRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::RenameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::RenameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::RenameResponse)
+ == ::llcpp::fuchsia::io::Directory::RenameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::RenameResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::LinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::LinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::LinkRequest)
+ == ::llcpp::fuchsia::io::Directory::LinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::LinkRequest, src) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::LinkRequest, dst_parent_token) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::LinkRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::LinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::LinkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::LinkResponse)
+ == ::llcpp::fuchsia::io::Directory::LinkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::LinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::WatchRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::WatchRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::WatchRequest)
+ == ::llcpp::fuchsia::io::Directory::WatchRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::WatchRequest, mask) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::WatchRequest, options) == 20);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::WatchRequest, watcher) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::Directory::WatchResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::Directory::WatchResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::Directory::WatchResponse)
+ == ::llcpp::fuchsia::io::Directory::WatchResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::Directory::WatchResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest, mode) == 20);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest, path) == 24);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::OpenRequest, object) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnlinkRequest, path) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnlinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsRequest, max_bytes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::ReadDirentsResponse, dirents) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RewindResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetTokenResponse, token) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest, src) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest, dst_parent_token) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RenameRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::RenameResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest, src) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest, dst_parent_token) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::LinkRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::LinkResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest, mask) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest, options) == 20);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::WatchRequest, watcher) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::WatchResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::MountRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::MountRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::MountRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::MountRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountRequest, remote) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::MountResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::MountResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::MountResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::MountResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, remote) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, name) == 24);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateRequest, flags) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::MountAndCreateResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::UnmountNodeResponse, remote) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::QueryFilesystemResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse)
+ == ::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io::DirectoryAdmin::GetDevicePathResponse, path) == 24);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-io2/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-io2/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..0dd8c4c
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-io2/gen/llcpp/fidl.cc
@@ -0,0 +1,8966 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/io2/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace io2 {
+
+::llcpp::fuchsia::io2::MemoryInfo::Builder MemoryInfo::Build() {
+ return MemoryInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::MemoryInfo::Builder::set_buffer(::llcpp::fuchsia::mem::Range* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::io2::File_GetMemRange_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(File_GetMemRange_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(File_GetMemRange_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(File_GetMemRange_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::io2::TtyInfo::Builder TtyInfo::Build() {
+ return TtyInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::TtyInfo::Builder::set_event(::zx::eventpair* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::io2::File_Read_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(File_Read_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(File_Read_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(File_Read_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::io2::File_ReadAt_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(File_ReadAt_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(File_ReadAt_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(File_ReadAt_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::io2::Node_GetToken_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Node_GetToken_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Node_GetToken_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Node_GetToken_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::io2::PosixSocketInfo::Builder PosixSocketInfo::Build() {
+ return PosixSocketInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::PosixSocketInfo::Builder::set_socket(::zx::socket* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::io2::PipeInfo::Builder PipeInfo::Build() {
+ return PipeInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::PipeInfo::Builder::set_socket(::zx::socket* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Node_UpdateAttributes_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Node_UpdateAttributes_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Node_UpdateAttributes_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::io2::Node_Sync_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Node_Sync_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Node_Sync_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Node_Sync_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::io2::NodeAttributes::Builder NodeAttributes::Build() {
+ return NodeAttributes::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::NodeAttributes::Builder::set_protocols(::llcpp::fuchsia::io2::NodeProtocolSet* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::NodeAttributes::Builder::set_abilities(::llcpp::fuchsia::io2::Operations* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::NodeAttributes::Builder::set_content_size(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::NodeAttributes::Builder::set_storage_size(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::NodeAttributes::Builder::set_link_count(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::NodeAttributes::Builder::set_creation_time(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[6 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 6) {
+ max_ordinal_ = 6;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::NodeAttributes::Builder::set_modification_time(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[7 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 7) {
+ max_ordinal_ = 7;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::NodeAttributes::Builder::set_id(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[8 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 8) {
+ max_ordinal_ = 8;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::io2::Node_GetAttributes_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Node_GetAttributes_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Node_GetAttributes_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Node_GetAttributes_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::io2::DirectoryEntry::Builder DirectoryEntry::Build() {
+ return DirectoryEntry::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::DirectoryEntry::Builder::set_name(::fidl::StringView* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::DirectoryEntry::Builder::set_protocols(::llcpp::fuchsia::io2::NodeProtocolSet* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::DirectoryEntry::Builder::set_abilities(::llcpp::fuchsia::io2::Operations* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::DirectoryEntry::Builder::set_id(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+auto ::llcpp::fuchsia::io2::DirectoryWatchedEvent::which() const -> Tag {
+ ZX_ASSERT(!has_invalid_tag());
+ switch (ordinal()) {
+ case Ordinal::kExisting:
+ case Ordinal::kIdle:
+ case Ordinal::kAdded:
+ case Ordinal::kRemoved:
+ return static_cast<Tag>(ordinal());
+ default:
+ return Tag::kUnknown;
+ }
+}
+
+void ::llcpp::fuchsia::io2::DirectoryWatchedEvent::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DirectoryWatchedEvent) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DirectoryWatchedEvent, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DirectoryWatchedEvent, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDirectoryWatcher_GetNext_Ordinal = 0x7de5be100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryWatcher_GetNext_GenOrdinal = 0x74de3b9a6548cb77lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatcherGetNextRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatcherGetNextResponseTable;
+
+} // namespace
+template <>
+DirectoryWatcher::ResultOf::GetNext_Impl<DirectoryWatcher::GetNextResponse>::GetNext_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNextRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNextRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNextRequest));
+ ::fidl::DecodedMessage<GetNextRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryWatcher::InPlace::GetNext(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryWatcher::ResultOf::GetNext DirectoryWatcher::SyncClient::GetNext() {
+ return ResultOf::GetNext(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryWatcher::ResultOf::GetNext DirectoryWatcher::Call::GetNext(::zx::unowned_channel _client_end) {
+ return ResultOf::GetNext(std::move(_client_end));
+}
+
+template <>
+DirectoryWatcher::UnownedResultOf::GetNext_Impl<DirectoryWatcher::GetNextResponse>::GetNext_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNextRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetNextRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetNextRequest));
+ ::fidl::DecodedMessage<GetNextRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryWatcher::InPlace::GetNext(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryWatcher::UnownedResultOf::GetNext DirectoryWatcher::SyncClient::GetNext(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNext(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryWatcher::UnownedResultOf::GetNext DirectoryWatcher::Call::GetNext(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNext(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryWatcher::GetNextResponse> DirectoryWatcher::InPlace::GetNext(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetNextRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetNextRequest> params(std::move(_request_buffer));
+ DirectoryWatcher::SetTransactionHeaderFor::GetNextRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryWatcher::GetNextResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNextRequest, GetNextResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryWatcher::GetNextResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DirectoryWatcher::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDirectoryWatcher_GetNext_Ordinal:
+ case kDirectoryWatcher_GetNext_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNextRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetNext(
+ Interface::GetNextCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DirectoryWatcher::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DirectoryWatcher::Interface::GetNextCompleterBase::Reply(::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryWatchedEvent> events) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNextResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetNextResponse _response = {};
+ DirectoryWatcher::SetTransactionHeaderFor::GetNextResponse(
+ ::fidl::DecodedMessage<GetNextResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNextResponse::PrimarySize,
+ GetNextResponse::PrimarySize)));
+ _response.events = std::move(events);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryWatcher::Interface::GetNextCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryWatchedEvent> events) {
+ if (_buffer.capacity() < GetNextResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetNextResponse _response = {};
+ DirectoryWatcher::SetTransactionHeaderFor::GetNextResponse(
+ ::fidl::DecodedMessage<GetNextResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNextResponse::PrimarySize,
+ GetNextResponse::PrimarySize)));
+ _response.events = std::move(events);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirectoryWatcher::Interface::GetNextCompleterBase::Reply(::fidl::DecodedMessage<GetNextResponse> params) {
+ DirectoryWatcher::SetTransactionHeaderFor::GetNextResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DirectoryWatcher::SetTransactionHeaderFor::GetNextRequest(const ::fidl::DecodedMessage<DirectoryWatcher::GetNextRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryWatcher_GetNext_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryWatcher::SetTransactionHeaderFor::GetNextResponse(const ::fidl::DecodedMessage<DirectoryWatcher::GetNextResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryWatcher_GetNext_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DirectoryIterator_GetNext_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DirectoryIterator_GetNext_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DirectoryIterator_GetNext_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDirectoryIterator_GetNext_Ordinal = 0x70aca67800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectoryIterator_GetNext_GenOrdinal = 0x5d2068db7393845clu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryIteratorGetNextRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryIteratorGetNextResponseTable;
+
+} // namespace
+template <>
+DirectoryIterator::ResultOf::GetNext_Impl<DirectoryIterator::GetNextResponse>::GetNext_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNextRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetNextRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetNextRequest));
+ ::fidl::DecodedMessage<GetNextRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirectoryIterator::InPlace::GetNext(std::move(_client_end), Super::response_buffer()));
+}
+
+DirectoryIterator::ResultOf::GetNext DirectoryIterator::SyncClient::GetNext() {
+ return ResultOf::GetNext(::zx::unowned_channel(this->channel_));
+}
+
+DirectoryIterator::ResultOf::GetNext DirectoryIterator::Call::GetNext(::zx::unowned_channel _client_end) {
+ return ResultOf::GetNext(std::move(_client_end));
+}
+
+template <>
+DirectoryIterator::UnownedResultOf::GetNext_Impl<DirectoryIterator::GetNextResponse>::GetNext_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetNextRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetNextRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetNextRequest));
+ ::fidl::DecodedMessage<GetNextRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirectoryIterator::InPlace::GetNext(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirectoryIterator::UnownedResultOf::GetNext DirectoryIterator::SyncClient::GetNext(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNext(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirectoryIterator::UnownedResultOf::GetNext DirectoryIterator::Call::GetNext(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetNext(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirectoryIterator::GetNextResponse> DirectoryIterator::InPlace::GetNext(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetNextRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetNextRequest> params(std::move(_request_buffer));
+ DirectoryIterator::SetTransactionHeaderFor::GetNextRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryIterator::GetNextResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetNextRequest, GetNextResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirectoryIterator::GetNextResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DirectoryIterator::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDirectoryIterator_GetNext_Ordinal:
+ case kDirectoryIterator_GetNext_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetNextRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetNext(
+ Interface::GetNextCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DirectoryIterator::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DirectoryIterator::Interface::GetNextCompleterBase::Reply(::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetNextResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetNextResponse _response = {};
+ DirectoryIterator::SetTransactionHeaderFor::GetNextResponse(
+ ::fidl::DecodedMessage<GetNextResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNextResponse::PrimarySize,
+ GetNextResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DirectoryIterator::Interface::GetNextCompleterBase::ReplySuccess(::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryEntry> entries) {
+ DirectoryIterator_GetNext_Response response;
+ response.entries = std::move(entries);
+
+ Reply(DirectoryIterator_GetNext_Result::WithResponse(&response));
+}
+void DirectoryIterator::Interface::GetNextCompleterBase::ReplyError(int32_t error) {
+ Reply(DirectoryIterator_GetNext_Result::WithErr(&error));
+}
+
+void DirectoryIterator::Interface::GetNextCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Result result) {
+ if (_buffer.capacity() < GetNextResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetNextResponse _response = {};
+ DirectoryIterator::SetTransactionHeaderFor::GetNextResponse(
+ ::fidl::DecodedMessage<GetNextResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetNextResponse::PrimarySize,
+ GetNextResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DirectoryIterator::Interface::GetNextCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryEntry> entries) {
+ DirectoryIterator_GetNext_Response response;
+ response.entries = std::move(entries);
+
+ Reply(std::move(_buffer), DirectoryIterator_GetNext_Result::WithResponse(&response));
+}
+
+void DirectoryIterator::Interface::GetNextCompleterBase::Reply(::fidl::DecodedMessage<GetNextResponse> params) {
+ DirectoryIterator::SetTransactionHeaderFor::GetNextResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DirectoryIterator::SetTransactionHeaderFor::GetNextRequest(const ::fidl::DecodedMessage<DirectoryIterator::GetNextRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryIterator_GetNext_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirectoryIterator::SetTransactionHeaderFor::GetNextResponse(const ::fidl::DecodedMessage<DirectoryIterator::GetNextResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectoryIterator_GetNext_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::io2::File_Write_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(File_Write_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(File_Write_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(File_Write_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::io2::File_WriteAt_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(File_WriteAt_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(File_WriteAt_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(File_WriteAt_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::io2::File_Seek_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(File_Seek_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(File_Seek_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(File_Seek_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::io2::File_Resize_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(File_Resize_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(File_Resize_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(File_Resize_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::io2::FileInfo::Builder FileInfo::Build() {
+ return FileInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::FileInfo::Builder::set_observer(::zx::event* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::FileInfo::Builder::set_is_append(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+void ::llcpp::fuchsia::io2::Directory_Unlink_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Directory_Unlink_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Directory_Unlink_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Directory_Unlink_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::io2::Directory_Rename_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Directory_Rename_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Directory_Rename_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Directory_Rename_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::io2::Directory_Link_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Directory_Link_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Directory_Link_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Directory_Link_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::io2::DirectoryWatchOptions::Builder DirectoryWatchOptions::Build() {
+ return DirectoryWatchOptions::Builder();
+}
+
+::llcpp::fuchsia::io2::DirectoryInfo::Builder DirectoryInfo::Build() {
+ return DirectoryInfo::Builder();
+}
+
+::llcpp::fuchsia::io2::DirectoryEnumerateOptions::Builder DirectoryEnumerateOptions::Build() {
+ return DirectoryEnumerateOptions::Builder();
+}
+
+::llcpp::fuchsia::io2::DeviceInfo::Builder DeviceInfo::Build() {
+ return DeviceInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::DeviceInfo::Builder::set_event(::zx::eventpair* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::io2::DebuglogInfo::Builder DebuglogInfo::Build() {
+ return DebuglogInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::DebuglogInfo::Builder::set_debuglog(::zx::debuglog* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::io2::ConnectorInfo::Builder ConnectorInfo::Build() {
+ return ConnectorInfo::Builder();
+}
+auto ::llcpp::fuchsia::io2::Representation::which() const -> Tag {
+ ZX_ASSERT(!has_invalid_tag());
+ switch (ordinal()) {
+ case Ordinal::kConnector:
+ case Ordinal::kDirectory:
+ case Ordinal::kFile:
+ case Ordinal::kMemory:
+ case Ordinal::kPosixSocket:
+ case Ordinal::kPipe:
+ case Ordinal::kDebuglog:
+ case Ordinal::kDevice:
+ case Ordinal::kTty:
+ return static_cast<Tag>(ordinal());
+ default:
+ return Tag::kUnknown;
+ }
+}
+
+void ::llcpp::fuchsia::io2::Representation::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Representation) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Representation, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Representation, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::io2::ConnectionInfo::Builder ConnectionInfo::Build() {
+ return ConnectionInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::ConnectionInfo::Builder::set_representation(::llcpp::fuchsia::io2::Representation* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::ConnectionInfo::Builder::set_rights(::llcpp::fuchsia::io2::Operations* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::ConnectionInfo::Builder::set_available_operations(::llcpp::fuchsia::io2::Operations* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::io2::ConnectionOptions::Builder ConnectionOptions::Build() {
+ return ConnectionOptions::Builder();
+}
+
+auto ::llcpp::fuchsia::io2::ConnectionOptions::Builder::set_flags(::llcpp::fuchsia::io2::ConnectionFlags* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::ConnectionOptions::Builder::set_protocols(::llcpp::fuchsia::io2::NodeProtocolSet* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::io2::ConnectionOptions::Builder::set_rights(::llcpp::fuchsia::io2::Operations* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kNode_Reopen_Ordinal = 0x58b509fd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_Reopen_GenOrdinal = 0x74170eb73121c69flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeReopenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_Close_Ordinal = 0x1d6d8aad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_Close_GenOrdinal = 0x2dec2818386e5d68lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_Describe_Ordinal = 0x4c10829300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_Describe_GenOrdinal = 0x4aac591060c65c2flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_OnConnectionInfo_Ordinal = 0x774d459800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_OnConnectionInfo_GenOrdinal = 0x6637fc43ceeaa437lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeOnConnectionInfoEventTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_GetToken_Ordinal = 0x11b59cd700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_GetToken_GenOrdinal = 0x4f2b25c934c5d8e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_GetAttributes_Ordinal = 0x12cd1a6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_GetAttributes_GenOrdinal = 0x675e1e73d076d1e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeGetAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_UpdateAttributes_Ordinal = 0x7c3a238d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_UpdateAttributes_GenOrdinal = 0x7d59d73f59ba21b5lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeUpdateAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNode_Sync_Ordinal = 0x5de3a4cd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNode_Sync_GenOrdinal = 0xac3a8c1a2e063adlu;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeSyncResponseTable;
+
+} // namespace
+
+Node::ResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReopenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Node::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Node::ResultOf::Reopen Node::SyncClient::Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(options), std::move(object_request));
+}
+
+Node::ResultOf::Reopen Node::Call::Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(std::move(_client_end), std::move(options), std::move(object_request));
+}
+
+
+Node::UnownedResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ if (_request_buffer.capacity() < ReopenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Node::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Node::UnownedResultOf::Reopen Node::SyncClient::Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+Node::UnownedResultOf::Reopen Node::Call::Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(std::move(_client_end), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+::fidl::internal::StatusAndError Node::InPlace::Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params) {
+ Node::SetTransactionHeaderFor::ReopenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Node::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Node::InPlace::Close(std::move(_client_end)));
+}
+
+Node::ResultOf::Close Node::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Node::ResultOf::Close Node::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Node::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Node::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Node::ResultOf::Describe_Impl<Node::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Node::ResultOf::Describe Node::SyncClient::Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Node::ResultOf::Describe Node::Call::Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(std::move(_client_end), std::move(query));
+}
+
+template <>
+Node::UnownedResultOf::Describe_Impl<Node::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DescribeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DescribeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::Describe Node::SyncClient::Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::Describe Node::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::DescribeResponse> Node::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer) {
+ Node::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::GetToken_Impl<Node::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+Node::ResultOf::GetToken Node::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+Node::ResultOf::GetToken Node::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+Node::UnownedResultOf::GetToken_Impl<Node::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::GetToken Node::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::GetToken Node::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::GetTokenResponse> Node::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ Node::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::GetAttributes_Impl<Node::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Node::ResultOf::GetAttributes Node::SyncClient::GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Node::ResultOf::GetAttributes Node::Call::GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(std::move(_client_end), std::move(query));
+}
+
+template <>
+Node::UnownedResultOf::GetAttributes_Impl<Node::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::GetAttributes Node::SyncClient::GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::GetAttributes Node::Call::GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::GetAttributesResponse> Node::InPlace::GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Node::SetTransactionHeaderFor::GetAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::GetAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttributesRequest, GetAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::GetAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::UpdateAttributes_Impl<Node::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Node::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Node::ResultOf::UpdateAttributes Node::SyncClient::UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(attributes));
+}
+
+Node::ResultOf::UpdateAttributes Node::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(std::move(_client_end), std::move(attributes));
+}
+
+template <>
+Node::UnownedResultOf::UpdateAttributes_Impl<Node::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UpdateAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UpdateAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Node::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::UpdateAttributes Node::SyncClient::UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::UpdateAttributes Node::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(std::move(_client_end), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::UpdateAttributesResponse> Node::InPlace::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Node::SetTransactionHeaderFor::UpdateAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::UpdateAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UpdateAttributesRequest, UpdateAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::UpdateAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Node::ResultOf::Sync_Impl<Node::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Node::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Node::ResultOf::Sync Node::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Node::ResultOf::Sync Node::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Node::UnownedResultOf::Sync_Impl<Node::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Node::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Node::UnownedResultOf::Sync Node::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Node::UnownedResultOf::Sync Node::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Node::SyncResponse> Node::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Node::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Node::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Node::SyncClient::HandleEvents(Node::EventHandlers handlers) {
+ return Node::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Node::Call::HandleEvents(::zx::unowned_channel client_end, Node::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnConnectionInfoResponse::MaxNumHandles >= x) {
+ x = OnConnectionInfoResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kNode_OnConnectionInfo_Ordinal:
+ case kNode_OnConnectionInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnConnectionInfoResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_connection_info(std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Node::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kNode_Reopen_Ordinal:
+ case kNode_Reopen_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReopenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Reopen(std::move(message->options), std::move(message->object_request),
+ Interface::ReopenCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_Close_Ordinal:
+ case kNode_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_Describe_Ordinal:
+ case kNode_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Describe(std::move(message->query),
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_GetToken_Ordinal:
+ case kNode_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_GetAttributes_Ordinal:
+ case kNode_GetAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetAttributes(std::move(message->query),
+ Interface::GetAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_UpdateAttributes_Ordinal:
+ case kNode_UpdateAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UpdateAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UpdateAttributes(std::move(message->attributes),
+ Interface::UpdateAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kNode_Sync_Ordinal:
+ case kNode_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Node::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Node::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ DescribeResponse _response = {};
+ Node::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Node::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Node::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Node::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Node::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Node::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OnConnectionInfoResponse _response = {};
+ Node::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Node::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < OnConnectionInfoResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnConnectionInfoResponse _response = {};
+ Node::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Node::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params) {
+ Node::SetTransactionHeaderFor::OnConnectionInfoResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Node::Interface::GetTokenCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetTokenResponse _response = {};
+ Node::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Node::Interface::GetTokenCompleterBase::ReplySuccess(::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(Node_GetToken_Result::WithResponse(&response));
+}
+void Node::Interface::GetTokenCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetToken_Result::WithErr(&error));
+}
+
+void Node::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTokenResponse _response = {};
+ Node::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Node::Interface::GetTokenCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(std::move(_buffer), Node_GetToken_Result::WithResponse(&response));
+}
+
+void Node::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ Node::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::GetAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetAttributesResponse _response = {};
+ Node::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Node::Interface::GetAttributesCompleterBase::ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(Node_GetAttributes_Result::WithResponse(&response));
+}
+void Node::Interface::GetAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetAttributes_Result::WithErr(&error));
+}
+
+void Node::Interface::GetAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ if (_buffer.capacity() < GetAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetAttributesResponse _response = {};
+ Node::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Node::Interface::GetAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(std::move(_buffer), Node_GetAttributes_Result::WithResponse(&response));
+}
+
+void Node::Interface::GetAttributesCompleterBase::Reply(::fidl::DecodedMessage<GetAttributesResponse> params) {
+ Node::SetTransactionHeaderFor::GetAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::UpdateAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UpdateAttributesResponse _response = {};
+ Node::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Node::Interface::UpdateAttributesCompleterBase::ReplySuccess() {
+ Node_UpdateAttributes_Response response;
+
+ Reply(Node_UpdateAttributes_Result::WithResponse(&response));
+}
+void Node::Interface::UpdateAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_UpdateAttributes_Result::WithErr(&error));
+}
+
+void Node::Interface::UpdateAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ if (_buffer.capacity() < UpdateAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UpdateAttributesResponse _response = {};
+ Node::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Node::Interface::UpdateAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_UpdateAttributes_Response response;
+
+ Reply(std::move(_buffer), Node_UpdateAttributes_Result::WithResponse(&response));
+}
+
+void Node::Interface::UpdateAttributesCompleterBase::Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params) {
+ Node::SetTransactionHeaderFor::UpdateAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Node::Interface::SyncCompleterBase::Reply(::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SyncResponse _response = {};
+ Node::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Node::Interface::SyncCompleterBase::ReplySuccess() {
+ Node_Sync_Response response;
+
+ Reply(Node_Sync_Result::WithResponse(&response));
+}
+void Node::Interface::SyncCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_Sync_Result::WithErr(&error));
+}
+
+void Node::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SyncResponse _response = {};
+ Node::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Node::Interface::SyncCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_Sync_Response response;
+
+ Reply(std::move(_buffer), Node_Sync_Result::WithResponse(&response));
+}
+
+void Node::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Node::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Node::SetTransactionHeaderFor::ReopenRequest(const ::fidl::DecodedMessage<Node::ReopenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Reopen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Node::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Node::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Node::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::OnConnectionInfoResponse(const ::fidl::DecodedMessage<Node::OnConnectionInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_OnConnectionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<Node::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<Node::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::GetAttributesRequest(const ::fidl::DecodedMessage<Node::GetAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::GetAttributesResponse(const ::fidl::DecodedMessage<Node::GetAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::UpdateAttributesRequest(const ::fidl::DecodedMessage<Node::UpdateAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::UpdateAttributesResponse(const ::fidl::DecodedMessage<Node::UpdateAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Node::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Node::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Node::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Node::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNode_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kPipe_Reopen_Ordinal = 0x58b509fd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPipe_Reopen_GenOrdinal = 0x74170eb73121c69flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeReopenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPipe_Close_Ordinal = 0x1d6d8aad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPipe_Close_GenOrdinal = 0x2dec2818386e5d68lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPipe_Describe_Ordinal = 0x4c10829300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPipe_Describe_GenOrdinal = 0x4aac591060c65c2flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPipe_OnConnectionInfo_Ordinal = 0x774d459800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPipe_OnConnectionInfo_GenOrdinal = 0x6637fc43ceeaa437lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeOnConnectionInfoEventTable;
+[[maybe_unused]]
+constexpr uint64_t kPipe_GetToken_Ordinal = 0x11b59cd700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPipe_GetToken_GenOrdinal = 0x4f2b25c934c5d8e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPipe_GetAttributes_Ordinal = 0x12cd1a6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPipe_GetAttributes_GenOrdinal = 0x675e1e73d076d1e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeGetAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPipe_UpdateAttributes_Ordinal = 0x7c3a238d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPipe_UpdateAttributes_GenOrdinal = 0x7d59d73f59ba21b5lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeUpdateAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPipe_Sync_Ordinal = 0x5de3a4cd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPipe_Sync_GenOrdinal = 0xac3a8c1a2e063adlu;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeSyncResponseTable;
+
+} // namespace
+
+Pipe::ResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReopenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Pipe::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Pipe::ResultOf::Reopen Pipe::SyncClient::Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(options), std::move(object_request));
+}
+
+Pipe::ResultOf::Reopen Pipe::Call::Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(std::move(_client_end), std::move(options), std::move(object_request));
+}
+
+
+Pipe::UnownedResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ if (_request_buffer.capacity() < ReopenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Pipe::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Pipe::UnownedResultOf::Reopen Pipe::SyncClient::Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+Pipe::UnownedResultOf::Reopen Pipe::Call::Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(std::move(_client_end), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+::fidl::internal::StatusAndError Pipe::InPlace::Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params) {
+ Pipe::SetTransactionHeaderFor::ReopenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Pipe::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Pipe::InPlace::Close(std::move(_client_end)));
+}
+
+Pipe::ResultOf::Close Pipe::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Pipe::ResultOf::Close Pipe::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Pipe::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Pipe::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Pipe::ResultOf::Describe_Impl<Pipe::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Pipe::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Pipe::ResultOf::Describe Pipe::SyncClient::Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Pipe::ResultOf::Describe Pipe::Call::Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(std::move(_client_end), std::move(query));
+}
+
+template <>
+Pipe::UnownedResultOf::Describe_Impl<Pipe::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DescribeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DescribeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Pipe::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Pipe::UnownedResultOf::Describe Pipe::SyncClient::Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Pipe::UnownedResultOf::Describe Pipe::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Pipe::DescribeResponse> Pipe::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer) {
+ Pipe::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Pipe::ResultOf::GetToken_Impl<Pipe::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Pipe::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+Pipe::ResultOf::GetToken Pipe::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+Pipe::ResultOf::GetToken Pipe::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+Pipe::UnownedResultOf::GetToken_Impl<Pipe::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Pipe::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Pipe::UnownedResultOf::GetToken Pipe::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Pipe::UnownedResultOf::GetToken Pipe::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Pipe::GetTokenResponse> Pipe::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ Pipe::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Pipe::ResultOf::GetAttributes_Impl<Pipe::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Pipe::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Pipe::ResultOf::GetAttributes Pipe::SyncClient::GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Pipe::ResultOf::GetAttributes Pipe::Call::GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(std::move(_client_end), std::move(query));
+}
+
+template <>
+Pipe::UnownedResultOf::GetAttributes_Impl<Pipe::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Pipe::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Pipe::UnownedResultOf::GetAttributes Pipe::SyncClient::GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Pipe::UnownedResultOf::GetAttributes Pipe::Call::GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Pipe::GetAttributesResponse> Pipe::InPlace::GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Pipe::SetTransactionHeaderFor::GetAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::GetAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttributesRequest, GetAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::GetAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Pipe::ResultOf::UpdateAttributes_Impl<Pipe::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Pipe::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Pipe::ResultOf::UpdateAttributes Pipe::SyncClient::UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(attributes));
+}
+
+Pipe::ResultOf::UpdateAttributes Pipe::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(std::move(_client_end), std::move(attributes));
+}
+
+template <>
+Pipe::UnownedResultOf::UpdateAttributes_Impl<Pipe::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UpdateAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UpdateAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Pipe::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Pipe::UnownedResultOf::UpdateAttributes Pipe::SyncClient::UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+Pipe::UnownedResultOf::UpdateAttributes Pipe::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(std::move(_client_end), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Pipe::UpdateAttributesResponse> Pipe::InPlace::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Pipe::SetTransactionHeaderFor::UpdateAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::UpdateAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UpdateAttributesRequest, UpdateAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::UpdateAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Pipe::ResultOf::Sync_Impl<Pipe::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Pipe::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Pipe::ResultOf::Sync Pipe::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Pipe::ResultOf::Sync Pipe::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Pipe::UnownedResultOf::Sync_Impl<Pipe::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Pipe::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Pipe::UnownedResultOf::Sync Pipe::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Pipe::UnownedResultOf::Sync Pipe::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Pipe::SyncResponse> Pipe::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Pipe::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Pipe::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Pipe::SyncClient::HandleEvents(Pipe::EventHandlers handlers) {
+ return Pipe::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Pipe::Call::HandleEvents(::zx::unowned_channel client_end, Pipe::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnConnectionInfoResponse::MaxNumHandles >= x) {
+ x = OnConnectionInfoResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kPipe_OnConnectionInfo_Ordinal:
+ case kPipe_OnConnectionInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnConnectionInfoResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_connection_info(std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Pipe::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kPipe_Reopen_Ordinal:
+ case kPipe_Reopen_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReopenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Reopen(std::move(message->options), std::move(message->object_request),
+ Interface::ReopenCompleter::Sync(txn));
+ return true;
+ }
+ case kPipe_Close_Ordinal:
+ case kPipe_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kPipe_Describe_Ordinal:
+ case kPipe_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Describe(std::move(message->query),
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kPipe_GetToken_Ordinal:
+ case kPipe_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kPipe_GetAttributes_Ordinal:
+ case kPipe_GetAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetAttributes(std::move(message->query),
+ Interface::GetAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kPipe_UpdateAttributes_Ordinal:
+ case kPipe_UpdateAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UpdateAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UpdateAttributes(std::move(message->attributes),
+ Interface::UpdateAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kPipe_Sync_Ordinal:
+ case kPipe_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Pipe::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Pipe::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ DescribeResponse _response = {};
+ Pipe::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Pipe::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Pipe::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Pipe::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Pipe::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Pipe::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OnConnectionInfoResponse _response = {};
+ Pipe::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Pipe::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < OnConnectionInfoResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnConnectionInfoResponse _response = {};
+ Pipe::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Pipe::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params) {
+ Pipe::SetTransactionHeaderFor::OnConnectionInfoResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Pipe::Interface::GetTokenCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetTokenResponse _response = {};
+ Pipe::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Pipe::Interface::GetTokenCompleterBase::ReplySuccess(::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(Node_GetToken_Result::WithResponse(&response));
+}
+void Pipe::Interface::GetTokenCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetToken_Result::WithErr(&error));
+}
+
+void Pipe::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTokenResponse _response = {};
+ Pipe::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Pipe::Interface::GetTokenCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(std::move(_buffer), Node_GetToken_Result::WithResponse(&response));
+}
+
+void Pipe::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ Pipe::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Pipe::Interface::GetAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetAttributesResponse _response = {};
+ Pipe::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Pipe::Interface::GetAttributesCompleterBase::ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(Node_GetAttributes_Result::WithResponse(&response));
+}
+void Pipe::Interface::GetAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetAttributes_Result::WithErr(&error));
+}
+
+void Pipe::Interface::GetAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ if (_buffer.capacity() < GetAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetAttributesResponse _response = {};
+ Pipe::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Pipe::Interface::GetAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(std::move(_buffer), Node_GetAttributes_Result::WithResponse(&response));
+}
+
+void Pipe::Interface::GetAttributesCompleterBase::Reply(::fidl::DecodedMessage<GetAttributesResponse> params) {
+ Pipe::SetTransactionHeaderFor::GetAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Pipe::Interface::UpdateAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UpdateAttributesResponse _response = {};
+ Pipe::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Pipe::Interface::UpdateAttributesCompleterBase::ReplySuccess() {
+ Node_UpdateAttributes_Response response;
+
+ Reply(Node_UpdateAttributes_Result::WithResponse(&response));
+}
+void Pipe::Interface::UpdateAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_UpdateAttributes_Result::WithErr(&error));
+}
+
+void Pipe::Interface::UpdateAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ if (_buffer.capacity() < UpdateAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UpdateAttributesResponse _response = {};
+ Pipe::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Pipe::Interface::UpdateAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_UpdateAttributes_Response response;
+
+ Reply(std::move(_buffer), Node_UpdateAttributes_Result::WithResponse(&response));
+}
+
+void Pipe::Interface::UpdateAttributesCompleterBase::Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params) {
+ Pipe::SetTransactionHeaderFor::UpdateAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Pipe::Interface::SyncCompleterBase::Reply(::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SyncResponse _response = {};
+ Pipe::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Pipe::Interface::SyncCompleterBase::ReplySuccess() {
+ Node_Sync_Response response;
+
+ Reply(Node_Sync_Result::WithResponse(&response));
+}
+void Pipe::Interface::SyncCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_Sync_Result::WithErr(&error));
+}
+
+void Pipe::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SyncResponse _response = {};
+ Pipe::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Pipe::Interface::SyncCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_Sync_Response response;
+
+ Reply(std::move(_buffer), Node_Sync_Result::WithResponse(&response));
+}
+
+void Pipe::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Pipe::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Pipe::SetTransactionHeaderFor::ReopenRequest(const ::fidl::DecodedMessage<Pipe::ReopenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_Reopen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Pipe::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Pipe::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Pipe::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Pipe::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Pipe::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Pipe::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Pipe::SetTransactionHeaderFor::OnConnectionInfoResponse(const ::fidl::DecodedMessage<Pipe::OnConnectionInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_OnConnectionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Pipe::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<Pipe::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Pipe::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<Pipe::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Pipe::SetTransactionHeaderFor::GetAttributesRequest(const ::fidl::DecodedMessage<Pipe::GetAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Pipe::SetTransactionHeaderFor::GetAttributesResponse(const ::fidl::DecodedMessage<Pipe::GetAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Pipe::SetTransactionHeaderFor::UpdateAttributesRequest(const ::fidl::DecodedMessage<Pipe::UpdateAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Pipe::SetTransactionHeaderFor::UpdateAttributesResponse(const ::fidl::DecodedMessage<Pipe::UpdateAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Pipe::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Pipe::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Pipe::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Pipe::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPipe_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kMemory_Reopen_Ordinal = 0x58b509fd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMemory_Reopen_GenOrdinal = 0x74170eb73121c69flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryReopenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMemory_Close_Ordinal = 0x1d6d8aad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMemory_Close_GenOrdinal = 0x2dec2818386e5d68lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMemory_Describe_Ordinal = 0x4c10829300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMemory_Describe_GenOrdinal = 0x4aac591060c65c2flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMemory_OnConnectionInfo_Ordinal = 0x774d459800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMemory_OnConnectionInfo_GenOrdinal = 0x6637fc43ceeaa437lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryOnConnectionInfoEventTable;
+[[maybe_unused]]
+constexpr uint64_t kMemory_GetToken_Ordinal = 0x11b59cd700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMemory_GetToken_GenOrdinal = 0x4f2b25c934c5d8e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMemory_GetAttributes_Ordinal = 0x12cd1a6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMemory_GetAttributes_GenOrdinal = 0x675e1e73d076d1e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryGetAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMemory_UpdateAttributes_Ordinal = 0x7c3a238d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMemory_UpdateAttributes_GenOrdinal = 0x7d59d73f59ba21b5lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryUpdateAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMemory_Sync_Ordinal = 0x5de3a4cd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMemory_Sync_GenOrdinal = 0xac3a8c1a2e063adlu;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemorySyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemorySyncResponseTable;
+
+} // namespace
+
+Memory::ResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReopenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Memory::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Memory::ResultOf::Reopen Memory::SyncClient::Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(options), std::move(object_request));
+}
+
+Memory::ResultOf::Reopen Memory::Call::Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(std::move(_client_end), std::move(options), std::move(object_request));
+}
+
+
+Memory::UnownedResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ if (_request_buffer.capacity() < ReopenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Memory::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Memory::UnownedResultOf::Reopen Memory::SyncClient::Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+Memory::UnownedResultOf::Reopen Memory::Call::Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(std::move(_client_end), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+::fidl::internal::StatusAndError Memory::InPlace::Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params) {
+ Memory::SetTransactionHeaderFor::ReopenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Memory::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Memory::InPlace::Close(std::move(_client_end)));
+}
+
+Memory::ResultOf::Close Memory::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Memory::ResultOf::Close Memory::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Memory::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Memory::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Memory::ResultOf::Describe_Impl<Memory::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Memory::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Memory::ResultOf::Describe Memory::SyncClient::Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Memory::ResultOf::Describe Memory::Call::Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(std::move(_client_end), std::move(query));
+}
+
+template <>
+Memory::UnownedResultOf::Describe_Impl<Memory::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DescribeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DescribeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Memory::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Memory::UnownedResultOf::Describe Memory::SyncClient::Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Memory::UnownedResultOf::Describe Memory::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Memory::DescribeResponse> Memory::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer) {
+ Memory::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Memory::ResultOf::GetToken_Impl<Memory::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Memory::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+Memory::ResultOf::GetToken Memory::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+Memory::ResultOf::GetToken Memory::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+Memory::UnownedResultOf::GetToken_Impl<Memory::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Memory::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Memory::UnownedResultOf::GetToken Memory::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Memory::UnownedResultOf::GetToken Memory::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Memory::GetTokenResponse> Memory::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ Memory::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Memory::ResultOf::GetAttributes_Impl<Memory::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Memory::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Memory::ResultOf::GetAttributes Memory::SyncClient::GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Memory::ResultOf::GetAttributes Memory::Call::GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(std::move(_client_end), std::move(query));
+}
+
+template <>
+Memory::UnownedResultOf::GetAttributes_Impl<Memory::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Memory::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Memory::UnownedResultOf::GetAttributes Memory::SyncClient::GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Memory::UnownedResultOf::GetAttributes Memory::Call::GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Memory::GetAttributesResponse> Memory::InPlace::GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Memory::SetTransactionHeaderFor::GetAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::GetAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttributesRequest, GetAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::GetAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Memory::ResultOf::UpdateAttributes_Impl<Memory::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Memory::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Memory::ResultOf::UpdateAttributes Memory::SyncClient::UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(attributes));
+}
+
+Memory::ResultOf::UpdateAttributes Memory::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(std::move(_client_end), std::move(attributes));
+}
+
+template <>
+Memory::UnownedResultOf::UpdateAttributes_Impl<Memory::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UpdateAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UpdateAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Memory::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Memory::UnownedResultOf::UpdateAttributes Memory::SyncClient::UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+Memory::UnownedResultOf::UpdateAttributes Memory::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(std::move(_client_end), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Memory::UpdateAttributesResponse> Memory::InPlace::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Memory::SetTransactionHeaderFor::UpdateAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::UpdateAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UpdateAttributesRequest, UpdateAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::UpdateAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Memory::ResultOf::Sync_Impl<Memory::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Memory::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Memory::ResultOf::Sync Memory::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Memory::ResultOf::Sync Memory::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Memory::UnownedResultOf::Sync_Impl<Memory::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Memory::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Memory::UnownedResultOf::Sync Memory::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Memory::UnownedResultOf::Sync Memory::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Memory::SyncResponse> Memory::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Memory::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Memory::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Memory::SyncClient::HandleEvents(Memory::EventHandlers handlers) {
+ return Memory::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Memory::Call::HandleEvents(::zx::unowned_channel client_end, Memory::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnConnectionInfoResponse::MaxNumHandles >= x) {
+ x = OnConnectionInfoResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kMemory_OnConnectionInfo_Ordinal:
+ case kMemory_OnConnectionInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnConnectionInfoResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_connection_info(std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Memory::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kMemory_Reopen_Ordinal:
+ case kMemory_Reopen_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReopenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Reopen(std::move(message->options), std::move(message->object_request),
+ Interface::ReopenCompleter::Sync(txn));
+ return true;
+ }
+ case kMemory_Close_Ordinal:
+ case kMemory_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kMemory_Describe_Ordinal:
+ case kMemory_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Describe(std::move(message->query),
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kMemory_GetToken_Ordinal:
+ case kMemory_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kMemory_GetAttributes_Ordinal:
+ case kMemory_GetAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetAttributes(std::move(message->query),
+ Interface::GetAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kMemory_UpdateAttributes_Ordinal:
+ case kMemory_UpdateAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UpdateAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UpdateAttributes(std::move(message->attributes),
+ Interface::UpdateAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kMemory_Sync_Ordinal:
+ case kMemory_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Memory::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Memory::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ DescribeResponse _response = {};
+ Memory::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Memory::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Memory::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Memory::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Memory::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Memory::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OnConnectionInfoResponse _response = {};
+ Memory::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Memory::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < OnConnectionInfoResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnConnectionInfoResponse _response = {};
+ Memory::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Memory::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params) {
+ Memory::SetTransactionHeaderFor::OnConnectionInfoResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Memory::Interface::GetTokenCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetTokenResponse _response = {};
+ Memory::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Memory::Interface::GetTokenCompleterBase::ReplySuccess(::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(Node_GetToken_Result::WithResponse(&response));
+}
+void Memory::Interface::GetTokenCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetToken_Result::WithErr(&error));
+}
+
+void Memory::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTokenResponse _response = {};
+ Memory::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Memory::Interface::GetTokenCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(std::move(_buffer), Node_GetToken_Result::WithResponse(&response));
+}
+
+void Memory::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ Memory::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Memory::Interface::GetAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetAttributesResponse _response = {};
+ Memory::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Memory::Interface::GetAttributesCompleterBase::ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(Node_GetAttributes_Result::WithResponse(&response));
+}
+void Memory::Interface::GetAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetAttributes_Result::WithErr(&error));
+}
+
+void Memory::Interface::GetAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ if (_buffer.capacity() < GetAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetAttributesResponse _response = {};
+ Memory::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Memory::Interface::GetAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(std::move(_buffer), Node_GetAttributes_Result::WithResponse(&response));
+}
+
+void Memory::Interface::GetAttributesCompleterBase::Reply(::fidl::DecodedMessage<GetAttributesResponse> params) {
+ Memory::SetTransactionHeaderFor::GetAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Memory::Interface::UpdateAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UpdateAttributesResponse _response = {};
+ Memory::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Memory::Interface::UpdateAttributesCompleterBase::ReplySuccess() {
+ Node_UpdateAttributes_Response response;
+
+ Reply(Node_UpdateAttributes_Result::WithResponse(&response));
+}
+void Memory::Interface::UpdateAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_UpdateAttributes_Result::WithErr(&error));
+}
+
+void Memory::Interface::UpdateAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ if (_buffer.capacity() < UpdateAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UpdateAttributesResponse _response = {};
+ Memory::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Memory::Interface::UpdateAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_UpdateAttributes_Response response;
+
+ Reply(std::move(_buffer), Node_UpdateAttributes_Result::WithResponse(&response));
+}
+
+void Memory::Interface::UpdateAttributesCompleterBase::Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params) {
+ Memory::SetTransactionHeaderFor::UpdateAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Memory::Interface::SyncCompleterBase::Reply(::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SyncResponse _response = {};
+ Memory::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Memory::Interface::SyncCompleterBase::ReplySuccess() {
+ Node_Sync_Response response;
+
+ Reply(Node_Sync_Result::WithResponse(&response));
+}
+void Memory::Interface::SyncCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_Sync_Result::WithErr(&error));
+}
+
+void Memory::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SyncResponse _response = {};
+ Memory::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Memory::Interface::SyncCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_Sync_Response response;
+
+ Reply(std::move(_buffer), Node_Sync_Result::WithResponse(&response));
+}
+
+void Memory::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Memory::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Memory::SetTransactionHeaderFor::ReopenRequest(const ::fidl::DecodedMessage<Memory::ReopenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_Reopen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Memory::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Memory::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Memory::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Memory::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Memory::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Memory::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Memory::SetTransactionHeaderFor::OnConnectionInfoResponse(const ::fidl::DecodedMessage<Memory::OnConnectionInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_OnConnectionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Memory::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<Memory::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Memory::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<Memory::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Memory::SetTransactionHeaderFor::GetAttributesRequest(const ::fidl::DecodedMessage<Memory::GetAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Memory::SetTransactionHeaderFor::GetAttributesResponse(const ::fidl::DecodedMessage<Memory::GetAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Memory::SetTransactionHeaderFor::UpdateAttributesRequest(const ::fidl::DecodedMessage<Memory::UpdateAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Memory::SetTransactionHeaderFor::UpdateAttributesResponse(const ::fidl::DecodedMessage<Memory::UpdateAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Memory::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Memory::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Memory::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Memory::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMemory_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kFile_Reopen_Ordinal = 0x58b509fd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Reopen_GenOrdinal = 0x74170eb73121c69flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReopenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Close_Ordinal = 0x1d6d8aad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Close_GenOrdinal = 0x2dec2818386e5d68lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Describe_Ordinal = 0x4c10829300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Describe_GenOrdinal = 0x4aac591060c65c2flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_OnConnectionInfo_Ordinal = 0x774d459800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_OnConnectionInfo_GenOrdinal = 0x6637fc43ceeaa437lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileOnConnectionInfoEventTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetToken_Ordinal = 0x11b59cd700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetToken_GenOrdinal = 0x4f2b25c934c5d8e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetAttributes_Ordinal = 0x12cd1a6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetAttributes_GenOrdinal = 0x675e1e73d076d1e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_UpdateAttributes_Ordinal = 0x7c3a238d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_UpdateAttributes_GenOrdinal = 0x7d59d73f59ba21b5lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileUpdateAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Sync_Ordinal = 0x5de3a4cd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Sync_GenOrdinal = 0xac3a8c1a2e063adlu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Seek_Ordinal = 0x3e95a93600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Seek_GenOrdinal = 0x6cd7bdfcc294f64elu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileSeekRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileSeekResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Read_Ordinal = 0x1a1df2b800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Read_GenOrdinal = 0x6ab0b2e9f1e01f70lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReadResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Write_Ordinal = 0xcc807f200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Write_GenOrdinal = 0x17872fc3d6725e01lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileWriteResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_ReadAt_Ordinal = 0x6b9eac3400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_ReadAt_GenOrdinal = 0x774898cce31c78aalu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReadAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReadAtResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_WriteAt_Ordinal = 0x40b5055d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_WriteAt_GenOrdinal = 0x7b2af74fa0191292lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileWriteAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileWriteAtResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_Resize_Ordinal = 0x24efd03800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_Resize_GenOrdinal = 0x57e9585fedaeaa1clu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileResizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileResizeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetMemRange_Ordinal = 0x150b497e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kFile_GetMemRange_GenOrdinal = 0x53842973559bd6ablu;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetMemRangeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetMemRangeResponseTable;
+
+} // namespace
+
+File::ResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReopenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ File::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+File::ResultOf::Reopen File::SyncClient::Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(options), std::move(object_request));
+}
+
+File::ResultOf::Reopen File::Call::Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(std::move(_client_end), std::move(options), std::move(object_request));
+}
+
+
+File::UnownedResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ if (_request_buffer.capacity() < ReopenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ File::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+File::UnownedResultOf::Reopen File::SyncClient::Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+File::UnownedResultOf::Reopen File::Call::Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(std::move(_client_end), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+::fidl::internal::StatusAndError File::InPlace::Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params) {
+ File::SetTransactionHeaderFor::ReopenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+File::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ File::InPlace::Close(std::move(_client_end)));
+}
+
+File::ResultOf::Close File::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::Close File::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError File::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+File::ResultOf::Describe_Impl<File::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Describe File::SyncClient::Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+File::ResultOf::Describe File::Call::Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(std::move(_client_end), std::move(query));
+}
+
+template <>
+File::UnownedResultOf::Describe_Impl<File::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DescribeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DescribeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Describe File::SyncClient::Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Describe File::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::DescribeResponse> File::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::GetToken_Impl<File::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+File::ResultOf::GetToken File::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::GetToken File::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+File::UnownedResultOf::GetToken_Impl<File::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::GetToken File::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::GetToken File::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::GetTokenResponse> File::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::GetAttributes_Impl<File::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::GetAttributes File::SyncClient::GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+File::ResultOf::GetAttributes File::Call::GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(std::move(_client_end), std::move(query));
+}
+
+template <>
+File::UnownedResultOf::GetAttributes_Impl<File::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::GetAttributes File::SyncClient::GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::GetAttributes File::Call::GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::GetAttributesResponse> File::InPlace::GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::GetAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttributesRequest, GetAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::UpdateAttributes_Impl<File::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::UpdateAttributes File::SyncClient::UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(attributes));
+}
+
+File::ResultOf::UpdateAttributes File::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(std::move(_client_end), std::move(attributes));
+}
+
+template <>
+File::UnownedResultOf::UpdateAttributes_Impl<File::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UpdateAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UpdateAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::UpdateAttributes File::SyncClient::UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::UpdateAttributes File::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(std::move(_client_end), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::UpdateAttributesResponse> File::InPlace::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::UpdateAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::UpdateAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UpdateAttributesRequest, UpdateAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::UpdateAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Sync_Impl<File::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+File::ResultOf::Sync File::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+File::ResultOf::Sync File::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+File::UnownedResultOf::Sync_Impl<File::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Sync File::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Sync File::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::SyncResponse> File::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ File::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Seek_Impl<File::SeekResponse>::Seek_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SeekRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SeekRequest*>(_write_bytes);
+ _request.origin = std::move(origin);
+ _request.offset = std::move(offset);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SeekRequest));
+ ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Seek(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Seek File::SyncClient::Seek(::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset) {
+ return ResultOf::Seek(::zx::unowned_channel(this->channel_), std::move(origin), std::move(offset));
+}
+
+File::ResultOf::Seek File::Call::Seek(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset) {
+ return ResultOf::Seek(std::move(_client_end), std::move(origin), std::move(offset));
+}
+
+template <>
+File::UnownedResultOf::Seek_Impl<File::SeekResponse>::Seek_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SeekRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SeekResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SeekRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SeekRequest*>(_request_buffer.data());
+ _request.origin = std::move(origin);
+ _request.offset = std::move(offset);
+ _request_buffer.set_actual(sizeof(SeekRequest));
+ ::fidl::DecodedMessage<SeekRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Seek(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Seek File::SyncClient::Seek(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Seek(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(origin), std::move(offset), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Seek File::Call::Seek(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Seek(std::move(_client_end), std::move(_request_buffer), std::move(origin), std::move(offset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::SeekResponse> File::InPlace::Seek(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::SeekRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SeekResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SeekRequest, SeekResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::SeekResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Read_Impl<File::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, uint64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_write_bytes);
+ _request.count = std::move(count);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Read(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Read File::SyncClient::Read(uint64_t count) {
+ return ResultOf::Read(::zx::unowned_channel(this->channel_), std::move(count));
+}
+
+File::ResultOf::Read File::Call::Read(::zx::unowned_channel _client_end, uint64_t count) {
+ return ResultOf::Read(std::move(_client_end), std::move(count));
+}
+
+template <>
+File::UnownedResultOf::Read_Impl<File::ReadResponse>::Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadRequest*>(_request_buffer.data());
+ _request.count = std::move(count);
+ _request_buffer.set_actual(sizeof(ReadRequest));
+ ::fidl::DecodedMessage<ReadRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Read(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Read File::SyncClient::Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Read File::Call::Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Read(std::move(_client_end), std::move(_request_buffer), std::move(count), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::ReadResponse> File::InPlace::Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::ReadRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ReadResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadRequest, ReadResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ReadResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Write_Impl<File::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::Write(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Write File::SyncClient::Write(::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Write(::zx::unowned_channel(this->channel_), std::move(data));
+}
+
+File::ResultOf::Write File::Call::Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data) {
+ return ResultOf::Write(std::move(_client_end), std::move(data));
+}
+
+template <>
+File::UnownedResultOf::Write_Impl<File::WriteResponse>::Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteRequest _request = {};
+ _request.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::Write(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Write File::SyncClient::Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Write File::Call::Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Write(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::WriteResponse> File::InPlace::Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::WriteRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::WriteResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteRequest, WriteResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::WriteResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::ReadAt_Impl<File::ReadAtResponse>::ReadAt_Impl(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAtRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadAtRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAtRequest*>(_write_bytes);
+ _request.count = std::move(count);
+ _request.offset = std::move(offset);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadAtRequest));
+ ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::ReadAt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::ReadAt File::SyncClient::ReadAt(uint64_t count, uint64_t offset) {
+ return ResultOf::ReadAt(::zx::unowned_channel(this->channel_), std::move(count), std::move(offset));
+}
+
+File::ResultOf::ReadAt File::Call::ReadAt(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset) {
+ return ResultOf::ReadAt(std::move(_client_end), std::move(count), std::move(offset));
+}
+
+template <>
+File::UnownedResultOf::ReadAt_Impl<File::ReadAtResponse>::ReadAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadAtRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadAtResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadAtRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAtRequest*>(_request_buffer.data());
+ _request.count = std::move(count);
+ _request.offset = std::move(offset);
+ _request_buffer.set_actual(sizeof(ReadAtRequest));
+ ::fidl::DecodedMessage<ReadAtRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::ReadAt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::ReadAt File::SyncClient::ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::ReadAt File::Call::ReadAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAt(std::move(_client_end), std::move(_request_buffer), std::move(count), std::move(offset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::ReadAtResponse> File::InPlace::ReadAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::ReadAtRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ReadAtResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadAtRequest, ReadAtResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ReadAtResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::WriteAt_Impl<File::WriteAtResponse>::WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteAtRequest _request = {};
+ _request.data = std::move(data);
+ _request.offset = std::move(offset);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::WriteAt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::WriteAt File::SyncClient::WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ return ResultOf::WriteAt(::zx::unowned_channel(this->channel_), std::move(data), std::move(offset));
+}
+
+File::ResultOf::WriteAt File::Call::WriteAt(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset) {
+ return ResultOf::WriteAt(std::move(_client_end), std::move(data), std::move(offset));
+}
+
+template <>
+File::UnownedResultOf::WriteAt_Impl<File::WriteAtResponse>::WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteAtRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteAtResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteAtRequest _request = {};
+ _request.data = std::move(data);
+ _request.offset = std::move(offset);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteAtRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ File::InPlace::WriteAt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::WriteAt File::SyncClient::WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::WriteAt File::Call::WriteAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAt(std::move(_client_end), std::move(_request_buffer), std::move(data), std::move(offset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::WriteAtResponse> File::InPlace::WriteAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::WriteAtRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::WriteAtResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteAtRequest, WriteAtResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::WriteAtResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::Resize_Impl<File::ResizeResponse>::Resize_Impl(::zx::unowned_channel _client_end, uint64_t length) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResizeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ResizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ResizeRequest*>(_write_bytes);
+ _request.length = std::move(length);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResizeRequest));
+ ::fidl::DecodedMessage<ResizeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::Resize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::Resize File::SyncClient::Resize(uint64_t length) {
+ return ResultOf::Resize(::zx::unowned_channel(this->channel_), std::move(length));
+}
+
+File::ResultOf::Resize File::Call::Resize(::zx::unowned_channel _client_end, uint64_t length) {
+ return ResultOf::Resize(std::move(_client_end), std::move(length));
+}
+
+template <>
+File::UnownedResultOf::Resize_Impl<File::ResizeResponse>::Resize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ResizeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ResizeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ResizeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ResizeRequest*>(_request_buffer.data());
+ _request.length = std::move(length);
+ _request_buffer.set_actual(sizeof(ResizeRequest));
+ ::fidl::DecodedMessage<ResizeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::Resize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::Resize File::SyncClient::Resize(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(length), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::Resize File::Call::Resize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resize(std::move(_client_end), std::move(_request_buffer), std::move(length), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::ResizeResponse> File::InPlace::Resize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResizeRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::ResizeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ResizeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ResizeRequest, ResizeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::ResizeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+File::ResultOf::GetMemRange_Impl<File::GetMemRangeResponse>::GetMemRange_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::VmoFlags flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMemRangeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetMemRangeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetMemRangeRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMemRangeRequest));
+ ::fidl::DecodedMessage<GetMemRangeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ File::InPlace::GetMemRange(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+File::ResultOf::GetMemRange File::SyncClient::GetMemRange(::llcpp::fuchsia::io2::VmoFlags flags) {
+ return ResultOf::GetMemRange(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+File::ResultOf::GetMemRange File::Call::GetMemRange(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::VmoFlags flags) {
+ return ResultOf::GetMemRange(std::move(_client_end), std::move(flags));
+}
+
+template <>
+File::UnownedResultOf::GetMemRange_Impl<File::GetMemRangeResponse>::GetMemRange_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::VmoFlags flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetMemRangeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetMemRangeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetMemRangeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetMemRangeRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(GetMemRangeRequest));
+ ::fidl::DecodedMessage<GetMemRangeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ File::InPlace::GetMemRange(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+File::UnownedResultOf::GetMemRange File::SyncClient::GetMemRange(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::VmoFlags flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMemRange(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+File::UnownedResultOf::GetMemRange File::Call::GetMemRange(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::VmoFlags flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMemRange(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<File::GetMemRangeResponse> File::InPlace::GetMemRange(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMemRangeRequest> params, ::fidl::BytePart response_buffer) {
+ File::SetTransactionHeaderFor::GetMemRangeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetMemRangeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetMemRangeRequest, GetMemRangeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<File::GetMemRangeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t File::SyncClient::HandleEvents(File::EventHandlers handlers) {
+ return File::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t File::Call::HandleEvents(::zx::unowned_channel client_end, File::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnConnectionInfoResponse::MaxNumHandles >= x) {
+ x = OnConnectionInfoResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kFile_OnConnectionInfo_Ordinal:
+ case kFile_OnConnectionInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnConnectionInfoResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_connection_info(std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool File::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kFile_Reopen_Ordinal:
+ case kFile_Reopen_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReopenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Reopen(std::move(message->options), std::move(message->object_request),
+ Interface::ReopenCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Close_Ordinal:
+ case kFile_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Describe_Ordinal:
+ case kFile_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Describe(std::move(message->query),
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_GetToken_Ordinal:
+ case kFile_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_GetAttributes_Ordinal:
+ case kFile_GetAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetAttributes(std::move(message->query),
+ Interface::GetAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_UpdateAttributes_Ordinal:
+ case kFile_UpdateAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UpdateAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UpdateAttributes(std::move(message->attributes),
+ Interface::UpdateAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Sync_Ordinal:
+ case kFile_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Seek_Ordinal:
+ case kFile_Seek_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SeekRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Seek(std::move(message->origin), std::move(message->offset),
+ Interface::SeekCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Read_Ordinal:
+ case kFile_Read_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Read(std::move(message->count),
+ Interface::ReadCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Write_Ordinal:
+ case kFile_Write_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Write(std::move(message->data),
+ Interface::WriteCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_ReadAt_Ordinal:
+ case kFile_ReadAt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadAtRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReadAt(std::move(message->count), std::move(message->offset),
+ Interface::ReadAtCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_WriteAt_Ordinal:
+ case kFile_WriteAt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteAtRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteAt(std::move(message->data), std::move(message->offset),
+ Interface::WriteAtCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_Resize_Ordinal:
+ case kFile_Resize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ResizeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Resize(std::move(message->length),
+ Interface::ResizeCompleter::Sync(txn));
+ return true;
+ }
+ case kFile_GetMemRange_Ordinal:
+ case kFile_GetMemRange_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetMemRangeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetMemRange(std::move(message->flags),
+ Interface::GetMemRangeCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool File::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void File::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ DescribeResponse _response = {};
+ File::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ File::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void File::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ File::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t File::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OnConnectionInfoResponse _response = {};
+ File::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t File::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < OnConnectionInfoResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnConnectionInfoResponse _response = {};
+ File::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t File::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params) {
+ File::SetTransactionHeaderFor::OnConnectionInfoResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void File::Interface::GetTokenCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetTokenResponse _response = {};
+ File::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::GetTokenCompleterBase::ReplySuccess(::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(Node_GetToken_Result::WithResponse(&response));
+}
+void File::Interface::GetTokenCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetToken_Result::WithErr(&error));
+}
+
+void File::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTokenResponse _response = {};
+ File::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::GetTokenCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(std::move(_buffer), Node_GetToken_Result::WithResponse(&response));
+}
+
+void File::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ File::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::GetAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetAttributesResponse _response = {};
+ File::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::GetAttributesCompleterBase::ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(Node_GetAttributes_Result::WithResponse(&response));
+}
+void File::Interface::GetAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetAttributes_Result::WithErr(&error));
+}
+
+void File::Interface::GetAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ if (_buffer.capacity() < GetAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetAttributesResponse _response = {};
+ File::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::GetAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(std::move(_buffer), Node_GetAttributes_Result::WithResponse(&response));
+}
+
+void File::Interface::GetAttributesCompleterBase::Reply(::fidl::DecodedMessage<GetAttributesResponse> params) {
+ File::SetTransactionHeaderFor::GetAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::UpdateAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UpdateAttributesResponse _response = {};
+ File::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::UpdateAttributesCompleterBase::ReplySuccess() {
+ Node_UpdateAttributes_Response response;
+
+ Reply(Node_UpdateAttributes_Result::WithResponse(&response));
+}
+void File::Interface::UpdateAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_UpdateAttributes_Result::WithErr(&error));
+}
+
+void File::Interface::UpdateAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ if (_buffer.capacity() < UpdateAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UpdateAttributesResponse _response = {};
+ File::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::UpdateAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_UpdateAttributes_Response response;
+
+ Reply(std::move(_buffer), Node_UpdateAttributes_Result::WithResponse(&response));
+}
+
+void File::Interface::UpdateAttributesCompleterBase::Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params) {
+ File::SetTransactionHeaderFor::UpdateAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::SyncCompleterBase::Reply(::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SyncResponse _response = {};
+ File::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::SyncCompleterBase::ReplySuccess() {
+ Node_Sync_Response response;
+
+ Reply(Node_Sync_Result::WithResponse(&response));
+}
+void File::Interface::SyncCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_Sync_Result::WithErr(&error));
+}
+
+void File::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SyncResponse _response = {};
+ File::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::SyncCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_Sync_Response response;
+
+ Reply(std::move(_buffer), Node_Sync_Result::WithResponse(&response));
+}
+
+void File::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ File::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::SeekCompleterBase::Reply(::llcpp::fuchsia::io2::File_Seek_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SeekResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SeekResponse _response = {};
+ File::SetTransactionHeaderFor::SeekResponse(
+ ::fidl::DecodedMessage<SeekResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SeekResponse::PrimarySize,
+ SeekResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::SeekCompleterBase::ReplySuccess(uint64_t offset_from_start) {
+ File_Seek_Response response;
+ response.offset_from_start = std::move(offset_from_start);
+
+ Reply(File_Seek_Result::WithResponse(&response));
+}
+void File::Interface::SeekCompleterBase::ReplyError(int32_t error) {
+ Reply(File_Seek_Result::WithErr(&error));
+}
+
+void File::Interface::SeekCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_Seek_Result result) {
+ if (_buffer.capacity() < SeekResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SeekResponse _response = {};
+ File::SetTransactionHeaderFor::SeekResponse(
+ ::fidl::DecodedMessage<SeekResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SeekResponse::PrimarySize,
+ SeekResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::SeekCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t offset_from_start) {
+ File_Seek_Response response;
+ response.offset_from_start = std::move(offset_from_start);
+
+ Reply(std::move(_buffer), File_Seek_Result::WithResponse(&response));
+}
+
+void File::Interface::SeekCompleterBase::Reply(::fidl::DecodedMessage<SeekResponse> params) {
+ File::SetTransactionHeaderFor::SeekResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::ReadCompleterBase::Reply(::llcpp::fuchsia::io2::File_Read_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadResponse _response = {};
+ File::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::ReadCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> data) {
+ File_Read_Response response;
+ response.data = std::move(data);
+
+ Reply(File_Read_Result::WithResponse(&response));
+}
+void File::Interface::ReadCompleterBase::ReplyError(int32_t error) {
+ Reply(File_Read_Result::WithErr(&error));
+}
+
+void File::Interface::ReadCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_Read_Result result) {
+ if (_buffer.capacity() < ReadResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadResponse _response = {};
+ File::SetTransactionHeaderFor::ReadResponse(
+ ::fidl::DecodedMessage<ReadResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadResponse::PrimarySize,
+ ReadResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::ReadCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data) {
+ File_Read_Response response;
+ response.data = std::move(data);
+
+ Reply(std::move(_buffer), File_Read_Result::WithResponse(&response));
+}
+
+void File::Interface::ReadCompleterBase::Reply(::fidl::DecodedMessage<ReadResponse> params) {
+ File::SetTransactionHeaderFor::ReadResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::WriteCompleterBase::Reply(::llcpp::fuchsia::io2::File_Write_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ WriteResponse _response = {};
+ File::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::WriteCompleterBase::ReplySuccess(uint64_t actual_count) {
+ File_Write_Response response;
+ response.actual_count = std::move(actual_count);
+
+ Reply(File_Write_Result::WithResponse(&response));
+}
+void File::Interface::WriteCompleterBase::ReplyError(int32_t error) {
+ Reply(File_Write_Result::WithErr(&error));
+}
+
+void File::Interface::WriteCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_Write_Result result) {
+ if (_buffer.capacity() < WriteResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WriteResponse _response = {};
+ File::SetTransactionHeaderFor::WriteResponse(
+ ::fidl::DecodedMessage<WriteResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteResponse::PrimarySize,
+ WriteResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::WriteCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t actual_count) {
+ File_Write_Response response;
+ response.actual_count = std::move(actual_count);
+
+ Reply(std::move(_buffer), File_Write_Result::WithResponse(&response));
+}
+
+void File::Interface::WriteCompleterBase::Reply(::fidl::DecodedMessage<WriteResponse> params) {
+ File::SetTransactionHeaderFor::WriteResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::ReadAtCompleterBase::Reply(::llcpp::fuchsia::io2::File_ReadAt_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAtResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ ReadAtResponse _response = {};
+ File::SetTransactionHeaderFor::ReadAtResponse(
+ ::fidl::DecodedMessage<ReadAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAtResponse::PrimarySize,
+ ReadAtResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::ReadAtCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> data) {
+ File_ReadAt_Response response;
+ response.data = std::move(data);
+
+ Reply(File_ReadAt_Result::WithResponse(&response));
+}
+void File::Interface::ReadAtCompleterBase::ReplyError(int32_t error) {
+ Reply(File_ReadAt_Result::WithErr(&error));
+}
+
+void File::Interface::ReadAtCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_ReadAt_Result result) {
+ if (_buffer.capacity() < ReadAtResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadAtResponse _response = {};
+ File::SetTransactionHeaderFor::ReadAtResponse(
+ ::fidl::DecodedMessage<ReadAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAtResponse::PrimarySize,
+ ReadAtResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::ReadAtCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data) {
+ File_ReadAt_Response response;
+ response.data = std::move(data);
+
+ Reply(std::move(_buffer), File_ReadAt_Result::WithResponse(&response));
+}
+
+void File::Interface::ReadAtCompleterBase::Reply(::fidl::DecodedMessage<ReadAtResponse> params) {
+ File::SetTransactionHeaderFor::ReadAtResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::WriteAtCompleterBase::Reply(::llcpp::fuchsia::io2::File_WriteAt_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAtResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ WriteAtResponse _response = {};
+ File::SetTransactionHeaderFor::WriteAtResponse(
+ ::fidl::DecodedMessage<WriteAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAtResponse::PrimarySize,
+ WriteAtResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::WriteAtCompleterBase::ReplySuccess(uint64_t actual_count) {
+ File_WriteAt_Response response;
+ response.actual_count = std::move(actual_count);
+
+ Reply(File_WriteAt_Result::WithResponse(&response));
+}
+void File::Interface::WriteAtCompleterBase::ReplyError(int32_t error) {
+ Reply(File_WriteAt_Result::WithErr(&error));
+}
+
+void File::Interface::WriteAtCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_WriteAt_Result result) {
+ if (_buffer.capacity() < WriteAtResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WriteAtResponse _response = {};
+ File::SetTransactionHeaderFor::WriteAtResponse(
+ ::fidl::DecodedMessage<WriteAtResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAtResponse::PrimarySize,
+ WriteAtResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::WriteAtCompleterBase::ReplySuccess(::fidl::BytePart _buffer, uint64_t actual_count) {
+ File_WriteAt_Response response;
+ response.actual_count = std::move(actual_count);
+
+ Reply(std::move(_buffer), File_WriteAt_Result::WithResponse(&response));
+}
+
+void File::Interface::WriteAtCompleterBase::Reply(::fidl::DecodedMessage<WriteAtResponse> params) {
+ File::SetTransactionHeaderFor::WriteAtResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::ResizeCompleterBase::Reply(::llcpp::fuchsia::io2::File_Resize_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResizeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ResizeResponse _response = {};
+ File::SetTransactionHeaderFor::ResizeResponse(
+ ::fidl::DecodedMessage<ResizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResizeResponse::PrimarySize,
+ ResizeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::ResizeCompleterBase::ReplySuccess() {
+ File_Resize_Response response;
+
+ Reply(File_Resize_Result::WithResponse(&response));
+}
+void File::Interface::ResizeCompleterBase::ReplyError(int32_t error) {
+ Reply(File_Resize_Result::WithErr(&error));
+}
+
+void File::Interface::ResizeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_Resize_Result result) {
+ if (_buffer.capacity() < ResizeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ResizeResponse _response = {};
+ File::SetTransactionHeaderFor::ResizeResponse(
+ ::fidl::DecodedMessage<ResizeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResizeResponse::PrimarySize,
+ ResizeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::ResizeCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ File_Resize_Response response;
+
+ Reply(std::move(_buffer), File_Resize_Result::WithResponse(&response));
+}
+
+void File::Interface::ResizeCompleterBase::Reply(::fidl::DecodedMessage<ResizeResponse> params) {
+ File::SetTransactionHeaderFor::ResizeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void File::Interface::GetMemRangeCompleterBase::Reply(::llcpp::fuchsia::io2::File_GetMemRange_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMemRangeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetMemRangeResponse _response = {};
+ File::SetTransactionHeaderFor::GetMemRangeResponse(
+ ::fidl::DecodedMessage<GetMemRangeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMemRangeResponse::PrimarySize,
+ GetMemRangeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::GetMemRangeCompleterBase::ReplySuccess(::llcpp::fuchsia::mem::Range buffer) {
+ File_GetMemRange_Response response;
+ response.buffer = std::move(buffer);
+
+ Reply(File_GetMemRange_Result::WithResponse(&response));
+}
+void File::Interface::GetMemRangeCompleterBase::ReplyError(int32_t error) {
+ Reply(File_GetMemRange_Result::WithErr(&error));
+}
+
+void File::Interface::GetMemRangeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_GetMemRange_Result result) {
+ if (_buffer.capacity() < GetMemRangeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetMemRangeResponse _response = {};
+ File::SetTransactionHeaderFor::GetMemRangeResponse(
+ ::fidl::DecodedMessage<GetMemRangeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMemRangeResponse::PrimarySize,
+ GetMemRangeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void File::Interface::GetMemRangeCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::mem::Range buffer) {
+ File_GetMemRange_Response response;
+ response.buffer = std::move(buffer);
+
+ Reply(std::move(_buffer), File_GetMemRange_Result::WithResponse(&response));
+}
+
+void File::Interface::GetMemRangeCompleterBase::Reply(::fidl::DecodedMessage<GetMemRangeResponse> params) {
+ File::SetTransactionHeaderFor::GetMemRangeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void File::SetTransactionHeaderFor::ReopenRequest(const ::fidl::DecodedMessage<File::ReopenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Reopen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<File::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<File::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<File::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::OnConnectionInfoResponse(const ::fidl::DecodedMessage<File::OnConnectionInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_OnConnectionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<File::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<File::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::GetAttributesRequest(const ::fidl::DecodedMessage<File::GetAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::GetAttributesResponse(const ::fidl::DecodedMessage<File::GetAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::UpdateAttributesRequest(const ::fidl::DecodedMessage<File::UpdateAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::UpdateAttributesResponse(const ::fidl::DecodedMessage<File::UpdateAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<File::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<File::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::SeekRequest(const ::fidl::DecodedMessage<File::SeekRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Seek_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::SeekResponse(const ::fidl::DecodedMessage<File::SeekResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Seek_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::ReadRequest(const ::fidl::DecodedMessage<File::ReadRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::ReadResponse(const ::fidl::DecodedMessage<File::ReadResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Read_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::WriteRequest(const ::fidl::DecodedMessage<File::WriteRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::WriteResponse(const ::fidl::DecodedMessage<File::WriteResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Write_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::ReadAtRequest(const ::fidl::DecodedMessage<File::ReadAtRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_ReadAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::ReadAtResponse(const ::fidl::DecodedMessage<File::ReadAtResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_ReadAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::WriteAtRequest(const ::fidl::DecodedMessage<File::WriteAtRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_WriteAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::WriteAtResponse(const ::fidl::DecodedMessage<File::WriteAtResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_WriteAt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::ResizeRequest(const ::fidl::DecodedMessage<File::ResizeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Resize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::ResizeResponse(const ::fidl::DecodedMessage<File::ResizeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_Resize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void File::SetTransactionHeaderFor::GetMemRangeRequest(const ::fidl::DecodedMessage<File::GetMemRangeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetMemRange_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void File::SetTransactionHeaderFor::GetMemRangeResponse(const ::fidl::DecodedMessage<File::GetMemRangeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kFile_GetMemRange_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Reopen_Ordinal = 0x58b509fd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Reopen_GenOrdinal = 0x74170eb73121c69flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryReopenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Close_Ordinal = 0x1d6d8aad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Close_GenOrdinal = 0x2dec2818386e5d68lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Describe_Ordinal = 0x4c10829300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Describe_GenOrdinal = 0x4aac591060c65c2flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_OnConnectionInfo_Ordinal = 0x774d459800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_OnConnectionInfo_GenOrdinal = 0x6637fc43ceeaa437lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryOnConnectionInfoEventTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_GetToken_Ordinal = 0x11b59cd700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_GetToken_GenOrdinal = 0x4f2b25c934c5d8e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_GetAttributes_Ordinal = 0x12cd1a6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_GetAttributes_GenOrdinal = 0x675e1e73d076d1e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryGetAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_UpdateAttributes_Ordinal = 0x7c3a238d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_UpdateAttributes_GenOrdinal = 0x7d59d73f59ba21b5lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryUpdateAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Sync_Ordinal = 0x5de3a4cd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Sync_GenOrdinal = 0xac3a8c1a2e063adlu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectorySyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectorySyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Open_Ordinal = 0x77699f2300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Open_GenOrdinal = 0x38473cc20ba23253lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryOpenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Unlink_Ordinal = 0x392cf05700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Unlink_GenOrdinal = 0x6c6dd97d65572cdblu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryUnlinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryUnlinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Enumerate_Ordinal = 0x2a43c2d300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Enumerate_GenOrdinal = 0xbe14c8b05a90a63lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryEnumerateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryEnumerateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Rename_Ordinal = 0x2ca2f41a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Rename_GenOrdinal = 0x1fe02df8f70742b7lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryRenameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryRenameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Link_Ordinal = 0x28f770e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Link_GenOrdinal = 0x42634f09df52fdcclu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryLinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryLinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Watch_Ordinal = 0x6a29d55100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirectory_Watch_GenOrdinal = 0x7f88ab8c3f500618lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatchResponseTable;
+
+} // namespace
+
+Directory::ResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReopenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::ResultOf::Reopen Directory::SyncClient::Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(options), std::move(object_request));
+}
+
+Directory::ResultOf::Reopen Directory::Call::Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(std::move(_client_end), std::move(options), std::move(object_request));
+}
+
+
+Directory::UnownedResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ if (_request_buffer.capacity() < ReopenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::UnownedResultOf::Reopen Directory::SyncClient::Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+Directory::UnownedResultOf::Reopen Directory::Call::Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(std::move(_client_end), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+::fidl::internal::StatusAndError Directory::InPlace::Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params) {
+ Directory::SetTransactionHeaderFor::ReopenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Directory::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Directory::InPlace::Close(std::move(_client_end)));
+}
+
+Directory::ResultOf::Close Directory::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::Close Directory::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Directory::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Directory::ResultOf::Describe_Impl<Directory::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::Describe Directory::SyncClient::Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Directory::ResultOf::Describe Directory::Call::Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(std::move(_client_end), std::move(query));
+}
+
+template <>
+Directory::UnownedResultOf::Describe_Impl<Directory::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DescribeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DescribeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Describe Directory::SyncClient::Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Describe Directory::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::DescribeResponse> Directory::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::GetToken_Impl<Directory::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::GetToken Directory::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::GetToken Directory::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::GetToken_Impl<Directory::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::GetToken Directory::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::GetToken Directory::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::GetTokenResponse> Directory::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::GetAttributes_Impl<Directory::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::GetAttributes Directory::SyncClient::GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Directory::ResultOf::GetAttributes Directory::Call::GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(std::move(_client_end), std::move(query));
+}
+
+template <>
+Directory::UnownedResultOf::GetAttributes_Impl<Directory::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::GetAttributes Directory::SyncClient::GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::GetAttributes Directory::Call::GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::GetAttributesResponse> Directory::InPlace::GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::GetAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::GetAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttributesRequest, GetAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::GetAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::UpdateAttributes_Impl<Directory::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::UpdateAttributes Directory::SyncClient::UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(attributes));
+}
+
+Directory::ResultOf::UpdateAttributes Directory::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(std::move(_client_end), std::move(attributes));
+}
+
+template <>
+Directory::UnownedResultOf::UpdateAttributes_Impl<Directory::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UpdateAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UpdateAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::UpdateAttributes Directory::SyncClient::UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::UpdateAttributes Directory::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(std::move(_client_end), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::UpdateAttributesResponse> Directory::InPlace::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::UpdateAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::UpdateAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UpdateAttributesRequest, UpdateAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::UpdateAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::Sync_Impl<Directory::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Directory::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Directory::ResultOf::Sync Directory::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Directory::ResultOf::Sync Directory::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Directory::UnownedResultOf::Sync_Impl<Directory::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Directory::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Sync Directory::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Sync Directory::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::SyncResponse> Directory::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Directory::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Directory::ResultOf::Open_Impl::Open_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ OpenRequest _request = {};
+ _request.path = std::move(path);
+ _request.mode = std::move(mode);
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Open(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::ResultOf::Open Directory::SyncClient::Open(::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Open(::zx::unowned_channel(this->channel_), std::move(path), std::move(mode), std::move(options), std::move(object_request));
+}
+
+Directory::ResultOf::Open Directory::Call::Open(::zx::unowned_channel _client_end, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Open(std::move(_client_end), std::move(path), std::move(mode), std::move(options), std::move(object_request));
+}
+
+
+Directory::UnownedResultOf::Open_Impl::Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ if (_request_buffer.capacity() < OpenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ OpenRequest _request = {};
+ _request.path = std::move(path);
+ _request.mode = std::move(mode);
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Open(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::UnownedResultOf::Open Directory::SyncClient::Open(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Open(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(path), std::move(mode), std::move(options), std::move(object_request));
+}
+
+Directory::UnownedResultOf::Open Directory::Call::Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Open(std::move(_client_end), std::move(_request_buffer), std::move(path), std::move(mode), std::move(options), std::move(object_request));
+}
+
+::fidl::internal::StatusAndError Directory::InPlace::Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params) {
+ Directory::SetTransactionHeaderFor::OpenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Directory::ResultOf::Unlink_Impl<Directory::UnlinkResponse>::Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ UnlinkRequest _request = {};
+ _request.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Unlink(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::Unlink Directory::SyncClient::Unlink(::fidl::StringView path) {
+ return ResultOf::Unlink(::zx::unowned_channel(this->channel_), std::move(path));
+}
+
+Directory::ResultOf::Unlink Directory::Call::Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path) {
+ return ResultOf::Unlink(std::move(_client_end), std::move(path));
+}
+
+template <>
+Directory::UnownedResultOf::Unlink_Impl<Directory::UnlinkResponse>::Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UnlinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UnlinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UnlinkRequest _request = {};
+ _request.path = std::move(path);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UnlinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Unlink(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Unlink Directory::SyncClient::Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unlink(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(path), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Unlink Directory::Call::Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Unlink(std::move(_client_end), std::move(_request_buffer), std::move(path), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::UnlinkResponse> Directory::InPlace::Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::UnlinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::UnlinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UnlinkRequest, UnlinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::UnlinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Directory::ResultOf::Enumerate_Impl::Enumerate_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EnumerateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ EnumerateRequest _request = {};
+ _request.options = std::move(options);
+ _request.iterator = std::move(iterator);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EnumerateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Enumerate(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::ResultOf::Enumerate Directory::SyncClient::Enumerate(::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator) {
+ return ResultOf::Enumerate(::zx::unowned_channel(this->channel_), std::move(options), std::move(iterator));
+}
+
+Directory::ResultOf::Enumerate Directory::Call::Enumerate(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator) {
+ return ResultOf::Enumerate(std::move(_client_end), std::move(options), std::move(iterator));
+}
+
+
+Directory::UnownedResultOf::Enumerate_Impl::Enumerate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator) {
+ if (_request_buffer.capacity() < EnumerateRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ EnumerateRequest _request = {};
+ _request.options = std::move(options);
+ _request.iterator = std::move(iterator);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EnumerateRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Enumerate(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::UnownedResultOf::Enumerate Directory::SyncClient::Enumerate(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator) {
+ return UnownedResultOf::Enumerate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(options), std::move(iterator));
+}
+
+Directory::UnownedResultOf::Enumerate Directory::Call::Enumerate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator) {
+ return UnownedResultOf::Enumerate(std::move(_client_end), std::move(_request_buffer), std::move(options), std::move(iterator));
+}
+
+::fidl::internal::StatusAndError Directory::InPlace::Enumerate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EnumerateRequest> params) {
+ Directory::SetTransactionHeaderFor::EnumerateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Directory::ResultOf::Rename_Impl<Directory::RenameResponse>::Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ RenameRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Rename(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::Rename Directory::SyncClient::Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Rename(::zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+Directory::ResultOf::Rename Directory::Call::Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Rename(std::move(_client_end), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+template <>
+Directory::UnownedResultOf::Rename_Impl<Directory::RenameResponse>::Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RenameRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RenameResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ RenameRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<RenameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Rename(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Rename Directory::SyncClient::Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rename(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Rename Directory::Call::Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Rename(std::move(_client_end), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::RenameResponse> Directory::InPlace::Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::RenameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::RenameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RenameRequest, RenameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::RenameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Directory::ResultOf::Link_Impl<Directory::LinkResponse>::Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LinkRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Link(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Directory::ResultOf::Link Directory::SyncClient::Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Link(::zx::unowned_channel(this->channel_), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+Directory::ResultOf::Link Directory::Call::Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst) {
+ return ResultOf::Link(std::move(_client_end), std::move(src), std::move(dst_parent_token), std::move(dst));
+}
+
+template <>
+Directory::UnownedResultOf::Link_Impl<Directory::LinkResponse>::Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LinkRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LinkResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LinkRequest _request = {};
+ _request.src = std::move(src);
+ _request.dst_parent_token = std::move(dst_parent_token);
+ _request.dst = std::move(dst);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LinkRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Directory::InPlace::Link(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Directory::UnownedResultOf::Link Directory::SyncClient::Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Link(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+Directory::UnownedResultOf::Link Directory::Call::Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Link(std::move(_client_end), std::move(_request_buffer), std::move(src), std::move(dst_parent_token), std::move(dst), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Directory::LinkResponse> Directory::InPlace::Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer) {
+ Directory::SetTransactionHeaderFor::LinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::LinkResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LinkRequest, LinkResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Directory::LinkResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Directory::ResultOf::Watch_Impl::Watch_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WatchRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ WatchRequest _request = {};
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WatchRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Watch(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::ResultOf::Watch Directory::SyncClient::Watch(::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher) {
+ return ResultOf::Watch(::zx::unowned_channel(this->channel_), std::move(mask), std::move(options), std::move(watcher));
+}
+
+Directory::ResultOf::Watch Directory::Call::Watch(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher) {
+ return ResultOf::Watch(std::move(_client_end), std::move(mask), std::move(options), std::move(watcher));
+}
+
+
+Directory::UnownedResultOf::Watch_Impl::Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher) {
+ if (_request_buffer.capacity() < WatchRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ WatchRequest _request = {};
+ _request.mask = std::move(mask);
+ _request.options = std::move(options);
+ _request.watcher = std::move(watcher);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WatchRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Directory::InPlace::Watch(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Directory::UnownedResultOf::Watch Directory::SyncClient::Watch(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher) {
+ return UnownedResultOf::Watch(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher));
+}
+
+Directory::UnownedResultOf::Watch Directory::Call::Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher) {
+ return UnownedResultOf::Watch(std::move(_client_end), std::move(_request_buffer), std::move(mask), std::move(options), std::move(watcher));
+}
+
+::fidl::internal::StatusAndError Directory::InPlace::Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params) {
+ Directory::SetTransactionHeaderFor::WatchRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+zx_status_t Directory::SyncClient::HandleEvents(Directory::EventHandlers handlers) {
+ return Directory::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Directory::Call::HandleEvents(::zx::unowned_channel client_end, Directory::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnConnectionInfoResponse::MaxNumHandles >= x) {
+ x = OnConnectionInfoResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kDirectory_OnConnectionInfo_Ordinal:
+ case kDirectory_OnConnectionInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnConnectionInfoResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_connection_info(std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Directory::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDirectory_Reopen_Ordinal:
+ case kDirectory_Reopen_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReopenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Reopen(std::move(message->options), std::move(message->object_request),
+ Interface::ReopenCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Close_Ordinal:
+ case kDirectory_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Describe_Ordinal:
+ case kDirectory_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Describe(std::move(message->query),
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_GetToken_Ordinal:
+ case kDirectory_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_GetAttributes_Ordinal:
+ case kDirectory_GetAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetAttributes(std::move(message->query),
+ Interface::GetAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_UpdateAttributes_Ordinal:
+ case kDirectory_UpdateAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UpdateAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UpdateAttributes(std::move(message->attributes),
+ Interface::UpdateAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Sync_Ordinal:
+ case kDirectory_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Open_Ordinal:
+ case kDirectory_Open_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Open(std::move(message->path), std::move(message->mode), std::move(message->options), std::move(message->object_request),
+ Interface::OpenCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Unlink_Ordinal:
+ case kDirectory_Unlink_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UnlinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Unlink(std::move(message->path),
+ Interface::UnlinkCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Enumerate_Ordinal:
+ case kDirectory_Enumerate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EnumerateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Enumerate(std::move(message->options), std::move(message->iterator),
+ Interface::EnumerateCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Rename_Ordinal:
+ case kDirectory_Rename_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RenameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Rename(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+ Interface::RenameCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Link_Ordinal:
+ case kDirectory_Link_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Link(std::move(message->src), std::move(message->dst_parent_token), std::move(message->dst),
+ Interface::LinkCompleter::Sync(txn));
+ return true;
+ }
+ case kDirectory_Watch_Ordinal:
+ case kDirectory_Watch_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WatchRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Watch(std::move(message->mask), std::move(message->options), std::move(message->watcher),
+ Interface::WatchCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Directory::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Directory::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ DescribeResponse _response = {};
+ Directory::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Directory::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Directory::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Directory::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Directory::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OnConnectionInfoResponse _response = {};
+ Directory::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Directory::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < OnConnectionInfoResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnConnectionInfoResponse _response = {};
+ Directory::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Directory::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params) {
+ Directory::SetTransactionHeaderFor::OnConnectionInfoResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Directory::Interface::GetTokenCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetTokenResponse _response = {};
+ Directory::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::GetTokenCompleterBase::ReplySuccess(::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(Node_GetToken_Result::WithResponse(&response));
+}
+void Directory::Interface::GetTokenCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetToken_Result::WithErr(&error));
+}
+
+void Directory::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTokenResponse _response = {};
+ Directory::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::GetTokenCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(std::move(_buffer), Node_GetToken_Result::WithResponse(&response));
+}
+
+void Directory::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ Directory::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::GetAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetAttributesResponse _response = {};
+ Directory::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::GetAttributesCompleterBase::ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(Node_GetAttributes_Result::WithResponse(&response));
+}
+void Directory::Interface::GetAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetAttributes_Result::WithErr(&error));
+}
+
+void Directory::Interface::GetAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ if (_buffer.capacity() < GetAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetAttributesResponse _response = {};
+ Directory::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::GetAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(std::move(_buffer), Node_GetAttributes_Result::WithResponse(&response));
+}
+
+void Directory::Interface::GetAttributesCompleterBase::Reply(::fidl::DecodedMessage<GetAttributesResponse> params) {
+ Directory::SetTransactionHeaderFor::GetAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::UpdateAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UpdateAttributesResponse _response = {};
+ Directory::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::UpdateAttributesCompleterBase::ReplySuccess() {
+ Node_UpdateAttributes_Response response;
+
+ Reply(Node_UpdateAttributes_Result::WithResponse(&response));
+}
+void Directory::Interface::UpdateAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_UpdateAttributes_Result::WithErr(&error));
+}
+
+void Directory::Interface::UpdateAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ if (_buffer.capacity() < UpdateAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UpdateAttributesResponse _response = {};
+ Directory::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::UpdateAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_UpdateAttributes_Response response;
+
+ Reply(std::move(_buffer), Node_UpdateAttributes_Result::WithResponse(&response));
+}
+
+void Directory::Interface::UpdateAttributesCompleterBase::Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params) {
+ Directory::SetTransactionHeaderFor::UpdateAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::SyncCompleterBase::Reply(::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SyncResponse _response = {};
+ Directory::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::SyncCompleterBase::ReplySuccess() {
+ Node_Sync_Response response;
+
+ Reply(Node_Sync_Result::WithResponse(&response));
+}
+void Directory::Interface::SyncCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_Sync_Result::WithErr(&error));
+}
+
+void Directory::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SyncResponse _response = {};
+ Directory::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::SyncCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_Sync_Response response;
+
+ Reply(std::move(_buffer), Node_Sync_Result::WithResponse(&response));
+}
+
+void Directory::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Directory::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::UnlinkCompleterBase::Reply(::llcpp::fuchsia::io2::Directory_Unlink_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UnlinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UnlinkResponse _response = {};
+ Directory::SetTransactionHeaderFor::UnlinkResponse(
+ ::fidl::DecodedMessage<UnlinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnlinkResponse::PrimarySize,
+ UnlinkResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::UnlinkCompleterBase::ReplySuccess() {
+ Directory_Unlink_Response response;
+
+ Reply(Directory_Unlink_Result::WithResponse(&response));
+}
+void Directory::Interface::UnlinkCompleterBase::ReplyError(int32_t error) {
+ Reply(Directory_Unlink_Result::WithErr(&error));
+}
+
+void Directory::Interface::UnlinkCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Directory_Unlink_Result result) {
+ if (_buffer.capacity() < UnlinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UnlinkResponse _response = {};
+ Directory::SetTransactionHeaderFor::UnlinkResponse(
+ ::fidl::DecodedMessage<UnlinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UnlinkResponse::PrimarySize,
+ UnlinkResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::UnlinkCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Directory_Unlink_Response response;
+
+ Reply(std::move(_buffer), Directory_Unlink_Result::WithResponse(&response));
+}
+
+void Directory::Interface::UnlinkCompleterBase::Reply(::fidl::DecodedMessage<UnlinkResponse> params) {
+ Directory::SetTransactionHeaderFor::UnlinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::RenameCompleterBase::Reply(::llcpp::fuchsia::io2::Directory_Rename_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RenameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ RenameResponse _response = {};
+ Directory::SetTransactionHeaderFor::RenameResponse(
+ ::fidl::DecodedMessage<RenameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RenameResponse::PrimarySize,
+ RenameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::RenameCompleterBase::ReplySuccess() {
+ Directory_Rename_Response response;
+
+ Reply(Directory_Rename_Result::WithResponse(&response));
+}
+void Directory::Interface::RenameCompleterBase::ReplyError(int32_t error) {
+ Reply(Directory_Rename_Result::WithErr(&error));
+}
+
+void Directory::Interface::RenameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Directory_Rename_Result result) {
+ if (_buffer.capacity() < RenameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RenameResponse _response = {};
+ Directory::SetTransactionHeaderFor::RenameResponse(
+ ::fidl::DecodedMessage<RenameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RenameResponse::PrimarySize,
+ RenameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::RenameCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Directory_Rename_Response response;
+
+ Reply(std::move(_buffer), Directory_Rename_Result::WithResponse(&response));
+}
+
+void Directory::Interface::RenameCompleterBase::Reply(::fidl::DecodedMessage<RenameResponse> params) {
+ Directory::SetTransactionHeaderFor::RenameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Directory::Interface::LinkCompleterBase::Reply(::llcpp::fuchsia::io2::Directory_Link_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LinkResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ LinkResponse _response = {};
+ Directory::SetTransactionHeaderFor::LinkResponse(
+ ::fidl::DecodedMessage<LinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LinkResponse::PrimarySize,
+ LinkResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::LinkCompleterBase::ReplySuccess() {
+ Directory_Link_Response response;
+
+ Reply(Directory_Link_Result::WithResponse(&response));
+}
+void Directory::Interface::LinkCompleterBase::ReplyError(int32_t error) {
+ Reply(Directory_Link_Result::WithErr(&error));
+}
+
+void Directory::Interface::LinkCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Directory_Link_Result result) {
+ if (_buffer.capacity() < LinkResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ LinkResponse _response = {};
+ Directory::SetTransactionHeaderFor::LinkResponse(
+ ::fidl::DecodedMessage<LinkResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LinkResponse::PrimarySize,
+ LinkResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Directory::Interface::LinkCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Directory_Link_Response response;
+
+ Reply(std::move(_buffer), Directory_Link_Result::WithResponse(&response));
+}
+
+void Directory::Interface::LinkCompleterBase::Reply(::fidl::DecodedMessage<LinkResponse> params) {
+ Directory::SetTransactionHeaderFor::LinkResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Directory::SetTransactionHeaderFor::ReopenRequest(const ::fidl::DecodedMessage<Directory::ReopenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Reopen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Directory::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Directory::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Directory::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::OnConnectionInfoResponse(const ::fidl::DecodedMessage<Directory::OnConnectionInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_OnConnectionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<Directory::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<Directory::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::GetAttributesRequest(const ::fidl::DecodedMessage<Directory::GetAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::GetAttributesResponse(const ::fidl::DecodedMessage<Directory::GetAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::UpdateAttributesRequest(const ::fidl::DecodedMessage<Directory::UpdateAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::UpdateAttributesResponse(const ::fidl::DecodedMessage<Directory::UpdateAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Directory::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Directory::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::OpenRequest(const ::fidl::DecodedMessage<Directory::OpenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Open_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::UnlinkRequest(const ::fidl::DecodedMessage<Directory::UnlinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Unlink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::UnlinkResponse(const ::fidl::DecodedMessage<Directory::UnlinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Unlink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::EnumerateRequest(const ::fidl::DecodedMessage<Directory::EnumerateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Enumerate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::RenameRequest(const ::fidl::DecodedMessage<Directory::RenameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Rename_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::RenameResponse(const ::fidl::DecodedMessage<Directory::RenameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Rename_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::LinkRequest(const ::fidl::DecodedMessage<Directory::LinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Link_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Directory::SetTransactionHeaderFor::LinkResponse(const ::fidl::DecodedMessage<Directory::LinkResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Link_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Directory::SetTransactionHeaderFor::WatchRequest(const ::fidl::DecodedMessage<Directory::WatchRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirectory_Watch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_Reopen_Ordinal = 0x58b509fd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_Reopen_GenOrdinal = 0x74170eb73121c69flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogReopenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_Close_Ordinal = 0x1d6d8aad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_Close_GenOrdinal = 0x2dec2818386e5d68lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_Describe_Ordinal = 0x4c10829300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_Describe_GenOrdinal = 0x4aac591060c65c2flu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_OnConnectionInfo_Ordinal = 0x774d459800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_OnConnectionInfo_GenOrdinal = 0x6637fc43ceeaa437lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogOnConnectionInfoEventTable;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_GetToken_Ordinal = 0x11b59cd700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_GetToken_GenOrdinal = 0x4f2b25c934c5d8e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogGetTokenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_GetAttributes_Ordinal = 0x12cd1a6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_GetAttributes_GenOrdinal = 0x675e1e73d076d1e4lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogGetAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_UpdateAttributes_Ordinal = 0x7c3a238d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_UpdateAttributes_GenOrdinal = 0x7d59d73f59ba21b5lu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogUpdateAttributesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_Sync_Ordinal = 0x5de3a4cd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebuglog_Sync_GenOrdinal = 0xac3a8c1a2e063adlu;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogSyncResponseTable;
+
+} // namespace
+
+Debuglog::ResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReopenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Debuglog::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Debuglog::ResultOf::Reopen Debuglog::SyncClient::Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(options), std::move(object_request));
+}
+
+Debuglog::ResultOf::Reopen Debuglog::Call::Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return ResultOf::Reopen(std::move(_client_end), std::move(options), std::move(object_request));
+}
+
+
+Debuglog::UnownedResultOf::Reopen_Impl::Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ if (_request_buffer.capacity() < ReopenRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ ReopenRequest _request = {};
+ _request.options = std::move(options);
+ _request.object_request = std::move(object_request);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ReopenRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Debuglog::InPlace::Reopen(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Debuglog::UnownedResultOf::Reopen Debuglog::SyncClient::Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+Debuglog::UnownedResultOf::Reopen Debuglog::Call::Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request) {
+ return UnownedResultOf::Reopen(std::move(_client_end), std::move(_request_buffer), std::move(options), std::move(object_request));
+}
+
+::fidl::internal::StatusAndError Debuglog::InPlace::Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params) {
+ Debuglog::SetTransactionHeaderFor::ReopenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Debuglog::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Debuglog::InPlace::Close(std::move(_client_end)));
+}
+
+Debuglog::ResultOf::Close Debuglog::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Debuglog::ResultOf::Close Debuglog::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Debuglog::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Debuglog::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Debuglog::ResultOf::Describe_Impl<Debuglog::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Debuglog::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Debuglog::ResultOf::Describe Debuglog::SyncClient::Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Debuglog::ResultOf::Describe Debuglog::Call::Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query) {
+ return ResultOf::Describe(std::move(_client_end), std::move(query));
+}
+
+template <>
+Debuglog::UnownedResultOf::Describe_Impl<Debuglog::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DescribeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DescribeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DescribeRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Debuglog::InPlace::Describe(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Debuglog::UnownedResultOf::Describe Debuglog::SyncClient::Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Debuglog::UnownedResultOf::Describe Debuglog::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Debuglog::DescribeResponse> Debuglog::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer) {
+ Debuglog::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Debuglog::ResultOf::GetToken_Impl<Debuglog::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetTokenRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Debuglog::InPlace::GetToken(std::move(_client_end), Super::response_buffer()));
+}
+
+Debuglog::ResultOf::GetToken Debuglog::SyncClient::GetToken() {
+ return ResultOf::GetToken(::zx::unowned_channel(this->channel_));
+}
+
+Debuglog::ResultOf::GetToken Debuglog::Call::GetToken(::zx::unowned_channel _client_end) {
+ return ResultOf::GetToken(std::move(_client_end));
+}
+
+template <>
+Debuglog::UnownedResultOf::GetToken_Impl<Debuglog::GetTokenResponse>::GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetTokenRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetTokenRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetTokenRequest));
+ ::fidl::DecodedMessage<GetTokenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Debuglog::InPlace::GetToken(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Debuglog::UnownedResultOf::GetToken Debuglog::SyncClient::GetToken(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Debuglog::UnownedResultOf::GetToken Debuglog::Call::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetToken(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Debuglog::GetTokenResponse> Debuglog::InPlace::GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetTokenRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetTokenRequest> params(std::move(_request_buffer));
+ Debuglog::SetTransactionHeaderFor::GetTokenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::GetTokenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetTokenRequest, GetTokenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::GetTokenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Debuglog::ResultOf::GetAttributes_Impl<Debuglog::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_write_bytes);
+ _request.query = std::move(query);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Debuglog::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Debuglog::ResultOf::GetAttributes Debuglog::SyncClient::GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(query));
+}
+
+Debuglog::ResultOf::GetAttributes Debuglog::Call::GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query) {
+ return ResultOf::GetAttributes(std::move(_client_end), std::move(query));
+}
+
+template <>
+Debuglog::UnownedResultOf::GetAttributes_Impl<Debuglog::GetAttributesResponse>::GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetAttributesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetAttributesRequest*>(_request_buffer.data());
+ _request.query = std::move(query);
+ _request_buffer.set_actual(sizeof(GetAttributesRequest));
+ ::fidl::DecodedMessage<GetAttributesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Debuglog::InPlace::GetAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Debuglog::UnownedResultOf::GetAttributes Debuglog::SyncClient::GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+Debuglog::UnownedResultOf::GetAttributes Debuglog::Call::GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttributes(std::move(_client_end), std::move(_request_buffer), std::move(query), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Debuglog::GetAttributesResponse> Debuglog::InPlace::GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Debuglog::SetTransactionHeaderFor::GetAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::GetAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttributesRequest, GetAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::GetAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Debuglog::ResultOf::UpdateAttributes_Impl<Debuglog::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Debuglog::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Debuglog::ResultOf::UpdateAttributes Debuglog::SyncClient::UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(attributes));
+}
+
+Debuglog::ResultOf::UpdateAttributes Debuglog::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ return ResultOf::UpdateAttributes(std::move(_client_end), std::move(attributes));
+}
+
+template <>
+Debuglog::UnownedResultOf::UpdateAttributes_Impl<Debuglog::UpdateAttributesResponse>::UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < UpdateAttributesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<UpdateAttributesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ UpdateAttributesRequest _request = {};
+ _request.attributes = std::move(attributes);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<UpdateAttributesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Debuglog::InPlace::UpdateAttributes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Debuglog::UnownedResultOf::UpdateAttributes Debuglog::SyncClient::UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+Debuglog::UnownedResultOf::UpdateAttributes Debuglog::Call::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateAttributes(std::move(_client_end), std::move(_request_buffer), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Debuglog::UpdateAttributesResponse> Debuglog::InPlace::UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer) {
+ Debuglog::SetTransactionHeaderFor::UpdateAttributesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::UpdateAttributesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UpdateAttributesRequest, UpdateAttributesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::UpdateAttributesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Debuglog::ResultOf::Sync_Impl<Debuglog::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Debuglog::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Debuglog::ResultOf::Sync Debuglog::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Debuglog::ResultOf::Sync Debuglog::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Debuglog::UnownedResultOf::Sync_Impl<Debuglog::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Debuglog::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Debuglog::UnownedResultOf::Sync Debuglog::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Debuglog::UnownedResultOf::Sync Debuglog::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Debuglog::SyncResponse> Debuglog::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Debuglog::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Debuglog::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Debuglog::SyncClient::HandleEvents(Debuglog::EventHandlers handlers) {
+ return Debuglog::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Debuglog::Call::HandleEvents(::zx::unowned_channel client_end, Debuglog::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnConnectionInfoResponse::MaxNumHandles >= x) {
+ x = OnConnectionInfoResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kDebuglog_OnConnectionInfo_Ordinal:
+ case kDebuglog_OnConnectionInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnConnectionInfoResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_connection_info(std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Debuglog::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDebuglog_Reopen_Ordinal:
+ case kDebuglog_Reopen_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReopenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Reopen(std::move(message->options), std::move(message->object_request),
+ Interface::ReopenCompleter::Sync(txn));
+ return true;
+ }
+ case kDebuglog_Close_Ordinal:
+ case kDebuglog_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kDebuglog_Describe_Ordinal:
+ case kDebuglog_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Describe(std::move(message->query),
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kDebuglog_GetToken_Ordinal:
+ case kDebuglog_GetToken_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetTokenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetToken(
+ Interface::GetTokenCompleter::Sync(txn));
+ return true;
+ }
+ case kDebuglog_GetAttributes_Ordinal:
+ case kDebuglog_GetAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetAttributes(std::move(message->query),
+ Interface::GetAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kDebuglog_UpdateAttributes_Ordinal:
+ case kDebuglog_UpdateAttributes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UpdateAttributesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UpdateAttributes(std::move(message->attributes),
+ Interface::UpdateAttributesCompleter::Sync(txn));
+ return true;
+ }
+ case kDebuglog_Sync_Ordinal:
+ case kDebuglog_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Debuglog::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Debuglog::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ DescribeResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Debuglog::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Debuglog::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Debuglog::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Debuglog::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnConnectionInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OnConnectionInfoResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Debuglog::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info) {
+ if (_buffer.capacity() < OnConnectionInfoResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnConnectionInfoResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::OnConnectionInfoResponse(
+ ::fidl::DecodedMessage<OnConnectionInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnConnectionInfoResponse::PrimarySize,
+ OnConnectionInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Debuglog::SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params) {
+ Debuglog::SetTransactionHeaderFor::OnConnectionInfoResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Debuglog::Interface::GetTokenCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetTokenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetTokenResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Debuglog::Interface::GetTokenCompleterBase::ReplySuccess(::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(Node_GetToken_Result::WithResponse(&response));
+}
+void Debuglog::Interface::GetTokenCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetToken_Result::WithErr(&error));
+}
+
+void Debuglog::Interface::GetTokenCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result) {
+ if (_buffer.capacity() < GetTokenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetTokenResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::GetTokenResponse(
+ ::fidl::DecodedMessage<GetTokenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetTokenResponse::PrimarySize,
+ GetTokenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Debuglog::Interface::GetTokenCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token) {
+ Node_GetToken_Response response;
+ response.token = std::move(token);
+
+ Reply(std::move(_buffer), Node_GetToken_Result::WithResponse(&response));
+}
+
+void Debuglog::Interface::GetTokenCompleterBase::Reply(::fidl::DecodedMessage<GetTokenResponse> params) {
+ Debuglog::SetTransactionHeaderFor::GetTokenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Debuglog::Interface::GetAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttributesResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetAttributesResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Debuglog::Interface::GetAttributesCompleterBase::ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(Node_GetAttributes_Result::WithResponse(&response));
+}
+void Debuglog::Interface::GetAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_GetAttributes_Result::WithErr(&error));
+}
+
+void Debuglog::Interface::GetAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result) {
+ if (_buffer.capacity() < GetAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetAttributesResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::GetAttributesResponse(
+ ::fidl::DecodedMessage<GetAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttributesResponse::PrimarySize,
+ GetAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Debuglog::Interface::GetAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes) {
+ Node_GetAttributes_Response response;
+ response.attributes = std::move(attributes);
+
+ Reply(std::move(_buffer), Node_GetAttributes_Result::WithResponse(&response));
+}
+
+void Debuglog::Interface::GetAttributesCompleterBase::Reply(::fidl::DecodedMessage<GetAttributesResponse> params) {
+ Debuglog::SetTransactionHeaderFor::GetAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Debuglog::Interface::UpdateAttributesCompleterBase::Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateAttributesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ UpdateAttributesResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Debuglog::Interface::UpdateAttributesCompleterBase::ReplySuccess() {
+ Node_UpdateAttributes_Response response;
+
+ Reply(Node_UpdateAttributes_Result::WithResponse(&response));
+}
+void Debuglog::Interface::UpdateAttributesCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_UpdateAttributes_Result::WithErr(&error));
+}
+
+void Debuglog::Interface::UpdateAttributesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result) {
+ if (_buffer.capacity() < UpdateAttributesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ UpdateAttributesResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::UpdateAttributesResponse(
+ ::fidl::DecodedMessage<UpdateAttributesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateAttributesResponse::PrimarySize,
+ UpdateAttributesResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Debuglog::Interface::UpdateAttributesCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_UpdateAttributes_Response response;
+
+ Reply(std::move(_buffer), Node_UpdateAttributes_Result::WithResponse(&response));
+}
+
+void Debuglog::Interface::UpdateAttributesCompleterBase::Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params) {
+ Debuglog::SetTransactionHeaderFor::UpdateAttributesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Debuglog::Interface::SyncCompleterBase::Reply(::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SyncResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Debuglog::Interface::SyncCompleterBase::ReplySuccess() {
+ Node_Sync_Response response;
+
+ Reply(Node_Sync_Result::WithResponse(&response));
+}
+void Debuglog::Interface::SyncCompleterBase::ReplyError(int32_t error) {
+ Reply(Node_Sync_Result::WithErr(&error));
+}
+
+void Debuglog::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SyncResponse _response = {};
+ Debuglog::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Debuglog::Interface::SyncCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Node_Sync_Response response;
+
+ Reply(std::move(_buffer), Node_Sync_Result::WithResponse(&response));
+}
+
+void Debuglog::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Debuglog::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Debuglog::SetTransactionHeaderFor::ReopenRequest(const ::fidl::DecodedMessage<Debuglog::ReopenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_Reopen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Debuglog::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Debuglog::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Debuglog::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Debuglog::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Debuglog::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Debuglog::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Debuglog::SetTransactionHeaderFor::OnConnectionInfoResponse(const ::fidl::DecodedMessage<Debuglog::OnConnectionInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_OnConnectionInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Debuglog::SetTransactionHeaderFor::GetTokenRequest(const ::fidl::DecodedMessage<Debuglog::GetTokenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Debuglog::SetTransactionHeaderFor::GetTokenResponse(const ::fidl::DecodedMessage<Debuglog::GetTokenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_GetToken_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Debuglog::SetTransactionHeaderFor::GetAttributesRequest(const ::fidl::DecodedMessage<Debuglog::GetAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Debuglog::SetTransactionHeaderFor::GetAttributesResponse(const ::fidl::DecodedMessage<Debuglog::GetAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_GetAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Debuglog::SetTransactionHeaderFor::UpdateAttributesRequest(const ::fidl::DecodedMessage<Debuglog::UpdateAttributesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Debuglog::SetTransactionHeaderFor::UpdateAttributesResponse(const ::fidl::DecodedMessage<Debuglog::UpdateAttributesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_UpdateAttributes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Debuglog::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Debuglog::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Debuglog::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Debuglog::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebuglog_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace io2
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-io2/gen/llcpp/include/fuchsia/io2/llcpp/fidl.h b/zircon/system/fidl/fuchsia-io2/gen/llcpp/include/fuchsia/io2/llcpp/fidl.h
new file mode 100644
index 0000000..cfcad20
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-io2/gen/llcpp/include/fuchsia/io2/llcpp/fidl.h
@@ -0,0 +1,14044 @@
+// 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/debuglog.h>
+#include <lib/zx/event.h>
+#include <lib/zx/eventpair.h>
+#include <lib/zx/handle.h>
+#include <lib/zx/socket.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/mem/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace io2 {
+
+struct MemoryInfo;
+struct File_GetMemRange_Response;
+struct File_GetMemRange_Result;
+class VmoFlags final {
+public:
+ constexpr VmoFlags() : value_(0u) {}
+ explicit constexpr VmoFlags(uint64_t value) : value_(value) {}
+ const static VmoFlags READ;
+ const static VmoFlags WRITE;
+ const static VmoFlags EXECUTE;
+ const static VmoFlags PRIVATE_CLONE;
+ const static VmoFlags SHARED_BUFFER;
+ const static VmoFlags mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const VmoFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const VmoFlags& other) const { return value_ != other.value_; }
+ constexpr inline VmoFlags operator~() const;
+ constexpr inline VmoFlags operator|(const VmoFlags& other) const;
+ constexpr inline VmoFlags operator&(const VmoFlags& other) const;
+ constexpr inline VmoFlags operator^(const VmoFlags& other) const;
+ constexpr inline void operator|=(const VmoFlags& other);
+ constexpr inline void operator&=(const VmoFlags& other);
+ constexpr inline void operator^=(const VmoFlags& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::VmoFlags VmoFlags::READ = ::llcpp::fuchsia::io2::VmoFlags(1u);
+constexpr const ::llcpp::fuchsia::io2::VmoFlags VmoFlags::WRITE = ::llcpp::fuchsia::io2::VmoFlags(2u);
+constexpr const ::llcpp::fuchsia::io2::VmoFlags VmoFlags::EXECUTE = ::llcpp::fuchsia::io2::VmoFlags(4u);
+constexpr const ::llcpp::fuchsia::io2::VmoFlags VmoFlags::PRIVATE_CLONE = ::llcpp::fuchsia::io2::VmoFlags(65536u);
+constexpr const ::llcpp::fuchsia::io2::VmoFlags VmoFlags::SHARED_BUFFER = ::llcpp::fuchsia::io2::VmoFlags(131072u);
+constexpr const ::llcpp::fuchsia::io2::VmoFlags VmoFlags::mask = ::llcpp::fuchsia::io2::VmoFlags(196615u);
+
+constexpr inline ::llcpp::fuchsia::io2::VmoFlags VmoFlags::operator~() const {
+ return ::llcpp::fuchsia::io2::VmoFlags(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::VmoFlags VmoFlags::operator|(
+ const ::llcpp::fuchsia::io2::VmoFlags& other) const {
+ return ::llcpp::fuchsia::io2::VmoFlags(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::VmoFlags VmoFlags::operator&(
+ const ::llcpp::fuchsia::io2::VmoFlags& other) const {
+ return ::llcpp::fuchsia::io2::VmoFlags(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::VmoFlags VmoFlags::operator^(
+ const ::llcpp::fuchsia::io2::VmoFlags& other) const {
+ return ::llcpp::fuchsia::io2::VmoFlags(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void VmoFlags::operator|=(
+ const ::llcpp::fuchsia::io2::VmoFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void VmoFlags::operator&=(
+ const ::llcpp::fuchsia::io2::VmoFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void VmoFlags::operator^=(
+ const ::llcpp::fuchsia::io2::VmoFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+struct TtyInfo;
+struct File_Read_Response;
+struct File_Read_Result;
+struct File_ReadAt_Response;
+struct File_ReadAt_Result;
+struct Node_GetToken_Response;
+struct Node_GetToken_Result;
+enum class SeekOrigin : uint32_t {
+ START = 1u,
+ CURRENT = 2u,
+ END = 3u,
+};
+
+
+struct PosixSocketInfo;
+struct PipeInfo;
+class Operations final {
+public:
+ constexpr Operations() : value_(0u) {}
+ explicit constexpr Operations(uint64_t value) : value_(value) {}
+ const static Operations CONNECT;
+ const static Operations READ_BYTES;
+ const static Operations WRITE_BYTES;
+ const static Operations EXECUTE;
+ const static Operations GET_ATTRIBUTES;
+ const static Operations UPDATE_ATTRIBUTES;
+ const static Operations ENUMERATE;
+ const static Operations TRAVERSE;
+ const static Operations MODIFY_DIRECTORY;
+ const static Operations ADMIN;
+ const static Operations mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const Operations& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const Operations& other) const { return value_ != other.value_; }
+ constexpr inline Operations operator~() const;
+ constexpr inline Operations operator|(const Operations& other) const;
+ constexpr inline Operations operator&(const Operations& other) const;
+ constexpr inline Operations operator^(const Operations& other) const;
+ constexpr inline void operator|=(const Operations& other);
+ constexpr inline void operator&=(const Operations& other);
+ constexpr inline void operator^=(const Operations& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::CONNECT = ::llcpp::fuchsia::io2::Operations(1u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::READ_BYTES = ::llcpp::fuchsia::io2::Operations(2u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::WRITE_BYTES = ::llcpp::fuchsia::io2::Operations(4u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::EXECUTE = ::llcpp::fuchsia::io2::Operations(8u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::GET_ATTRIBUTES = ::llcpp::fuchsia::io2::Operations(16u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::UPDATE_ATTRIBUTES = ::llcpp::fuchsia::io2::Operations(32u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::ENUMERATE = ::llcpp::fuchsia::io2::Operations(64u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::TRAVERSE = ::llcpp::fuchsia::io2::Operations(128u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::MODIFY_DIRECTORY = ::llcpp::fuchsia::io2::Operations(256u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::ADMIN = ::llcpp::fuchsia::io2::Operations(72057594037927936u);
+constexpr const ::llcpp::fuchsia::io2::Operations Operations::mask = ::llcpp::fuchsia::io2::Operations(72057594037928447u);
+
+constexpr inline ::llcpp::fuchsia::io2::Operations Operations::operator~() const {
+ return ::llcpp::fuchsia::io2::Operations(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::Operations Operations::operator|(
+ const ::llcpp::fuchsia::io2::Operations& other) const {
+ return ::llcpp::fuchsia::io2::Operations(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::Operations Operations::operator&(
+ const ::llcpp::fuchsia::io2::Operations& other) const {
+ return ::llcpp::fuchsia::io2::Operations(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::Operations Operations::operator^(
+ const ::llcpp::fuchsia::io2::Operations& other) const {
+ return ::llcpp::fuchsia::io2::Operations(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void Operations::operator|=(
+ const ::llcpp::fuchsia::io2::Operations& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void Operations::operator&=(
+ const ::llcpp::fuchsia::io2::Operations& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void Operations::operator^=(
+ const ::llcpp::fuchsia::io2::Operations& other) {
+ this->value_ ^= other.value_;
+}
+
+enum class OpenMode : uint32_t {
+ OPEN_EXISTING = 1u,
+ MAYBE_CREATE = 2u,
+ ALWAYS_CREATE = 3u,
+ OPEN_MOUNT_POINT = 268435456u,
+};
+
+
+struct Node_UpdateAttributes_Response;
+struct Node_UpdateAttributes_Result;
+struct Node_Sync_Response;
+struct Node_Sync_Result;
+class NodeProtocolSet final {
+public:
+ constexpr NodeProtocolSet() : value_(0u) {}
+ explicit constexpr NodeProtocolSet(uint64_t value) : value_(value) {}
+ const static NodeProtocolSet CONNECTOR;
+ const static NodeProtocolSet DIRECTORY;
+ const static NodeProtocolSet FILE;
+ const static NodeProtocolSet MEMORY;
+ const static NodeProtocolSet POSIX_SOCKET;
+ const static NodeProtocolSet PIPE;
+ const static NodeProtocolSet DEBUGLOG;
+ const static NodeProtocolSet DEVICE;
+ const static NodeProtocolSet TTY;
+ const static NodeProtocolSet mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const NodeProtocolSet& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const NodeProtocolSet& other) const { return value_ != other.value_; }
+ constexpr inline NodeProtocolSet operator~() const;
+ constexpr inline NodeProtocolSet operator|(const NodeProtocolSet& other) const;
+ constexpr inline NodeProtocolSet operator&(const NodeProtocolSet& other) const;
+ constexpr inline NodeProtocolSet operator^(const NodeProtocolSet& other) const;
+ constexpr inline void operator|=(const NodeProtocolSet& other);
+ constexpr inline void operator&=(const NodeProtocolSet& other);
+ constexpr inline void operator^=(const NodeProtocolSet& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::CONNECTOR = ::llcpp::fuchsia::io2::NodeProtocolSet(1u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::DIRECTORY = ::llcpp::fuchsia::io2::NodeProtocolSet(2u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::FILE = ::llcpp::fuchsia::io2::NodeProtocolSet(4u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::MEMORY = ::llcpp::fuchsia::io2::NodeProtocolSet(8u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::POSIX_SOCKET = ::llcpp::fuchsia::io2::NodeProtocolSet(16u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::PIPE = ::llcpp::fuchsia::io2::NodeProtocolSet(32u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::DEBUGLOG = ::llcpp::fuchsia::io2::NodeProtocolSet(64u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::DEVICE = ::llcpp::fuchsia::io2::NodeProtocolSet(268435456u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::TTY = ::llcpp::fuchsia::io2::NodeProtocolSet(536870912u);
+constexpr const ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::mask = ::llcpp::fuchsia::io2::NodeProtocolSet(805306495u);
+
+constexpr inline ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::operator~() const {
+ return ::llcpp::fuchsia::io2::NodeProtocolSet(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::operator|(
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& other) const {
+ return ::llcpp::fuchsia::io2::NodeProtocolSet(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::operator&(
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& other) const {
+ return ::llcpp::fuchsia::io2::NodeProtocolSet(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::NodeProtocolSet NodeProtocolSet::operator^(
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& other) const {
+ return ::llcpp::fuchsia::io2::NodeProtocolSet(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void NodeProtocolSet::operator|=(
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void NodeProtocolSet::operator&=(
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void NodeProtocolSet::operator^=(
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& other) {
+ this->value_ ^= other.value_;
+}
+
+class NodeAttributesQuery final {
+public:
+ constexpr NodeAttributesQuery() : value_(0u) {}
+ explicit constexpr NodeAttributesQuery(uint64_t value) : value_(value) {}
+ const static NodeAttributesQuery PROTOCOLS;
+ const static NodeAttributesQuery ABILITIES;
+ const static NodeAttributesQuery CONTENT_SIZE;
+ const static NodeAttributesQuery STORAGE_SIZE;
+ const static NodeAttributesQuery LINK_COUNT;
+ const static NodeAttributesQuery CREATION_TIME;
+ const static NodeAttributesQuery MODIFICATION_TIME;
+ const static NodeAttributesQuery ID;
+ const static NodeAttributesQuery mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const NodeAttributesQuery& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const NodeAttributesQuery& other) const { return value_ != other.value_; }
+ constexpr inline NodeAttributesQuery operator~() const;
+ constexpr inline NodeAttributesQuery operator|(const NodeAttributesQuery& other) const;
+ constexpr inline NodeAttributesQuery operator&(const NodeAttributesQuery& other) const;
+ constexpr inline NodeAttributesQuery operator^(const NodeAttributesQuery& other) const;
+ constexpr inline void operator|=(const NodeAttributesQuery& other);
+ constexpr inline void operator&=(const NodeAttributesQuery& other);
+ constexpr inline void operator^=(const NodeAttributesQuery& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::PROTOCOLS = ::llcpp::fuchsia::io2::NodeAttributesQuery(1u);
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::ABILITIES = ::llcpp::fuchsia::io2::NodeAttributesQuery(2u);
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::CONTENT_SIZE = ::llcpp::fuchsia::io2::NodeAttributesQuery(4u);
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::STORAGE_SIZE = ::llcpp::fuchsia::io2::NodeAttributesQuery(8u);
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::LINK_COUNT = ::llcpp::fuchsia::io2::NodeAttributesQuery(16u);
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::CREATION_TIME = ::llcpp::fuchsia::io2::NodeAttributesQuery(32u);
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::MODIFICATION_TIME = ::llcpp::fuchsia::io2::NodeAttributesQuery(64u);
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::ID = ::llcpp::fuchsia::io2::NodeAttributesQuery(128u);
+constexpr const ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::mask = ::llcpp::fuchsia::io2::NodeAttributesQuery(255u);
+
+constexpr inline ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::operator~() const {
+ return ::llcpp::fuchsia::io2::NodeAttributesQuery(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::operator|(
+ const ::llcpp::fuchsia::io2::NodeAttributesQuery& other) const {
+ return ::llcpp::fuchsia::io2::NodeAttributesQuery(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::operator&(
+ const ::llcpp::fuchsia::io2::NodeAttributesQuery& other) const {
+ return ::llcpp::fuchsia::io2::NodeAttributesQuery(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::NodeAttributesQuery NodeAttributesQuery::operator^(
+ const ::llcpp::fuchsia::io2::NodeAttributesQuery& other) const {
+ return ::llcpp::fuchsia::io2::NodeAttributesQuery(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void NodeAttributesQuery::operator|=(
+ const ::llcpp::fuchsia::io2::NodeAttributesQuery& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void NodeAttributesQuery::operator&=(
+ const ::llcpp::fuchsia::io2::NodeAttributesQuery& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void NodeAttributesQuery::operator^=(
+ const ::llcpp::fuchsia::io2::NodeAttributesQuery& other) {
+ this->value_ ^= other.value_;
+}
+
+struct IdleEvent;
+struct NodeAttributes;
+struct Node_GetAttributes_Response;
+struct Node_GetAttributes_Result;
+struct DirectoryEntry;
+struct DirectoryWatchedEvent;
+class DirectoryWatcher;
+struct DirectoryIterator_GetNext_Response;
+struct DirectoryIterator_GetNext_Result;
+class DirectoryIterator;
+struct File_Write_Response;
+struct File_Write_Result;
+struct File_WriteAt_Response;
+struct File_WriteAt_Result;
+struct File_Seek_Response;
+struct File_Seek_Result;
+struct File_Resize_Response;
+struct File_Resize_Result;
+class FileSignal final {
+public:
+ constexpr FileSignal() : value_(0u) {}
+ explicit constexpr FileSignal(uint32_t value) : value_(value) {}
+ const static FileSignal READABLE;
+ const static FileSignal WRITABLE;
+ const static FileSignal mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const FileSignal& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const FileSignal& other) const { return value_ != other.value_; }
+ constexpr inline FileSignal operator~() const;
+ constexpr inline FileSignal operator|(const FileSignal& other) const;
+ constexpr inline FileSignal operator&(const FileSignal& other) const;
+ constexpr inline FileSignal operator^(const FileSignal& other) const;
+ constexpr inline void operator|=(const FileSignal& other);
+ constexpr inline void operator&=(const FileSignal& other);
+ constexpr inline void operator^=(const FileSignal& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::FileSignal FileSignal::READABLE = ::llcpp::fuchsia::io2::FileSignal(16777216u);
+constexpr const ::llcpp::fuchsia::io2::FileSignal FileSignal::WRITABLE = ::llcpp::fuchsia::io2::FileSignal(33554432u);
+constexpr const ::llcpp::fuchsia::io2::FileSignal FileSignal::mask = ::llcpp::fuchsia::io2::FileSignal(50331648u);
+
+constexpr inline ::llcpp::fuchsia::io2::FileSignal FileSignal::operator~() const {
+ return ::llcpp::fuchsia::io2::FileSignal(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::FileSignal FileSignal::operator|(
+ const ::llcpp::fuchsia::io2::FileSignal& other) const {
+ return ::llcpp::fuchsia::io2::FileSignal(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::FileSignal FileSignal::operator&(
+ const ::llcpp::fuchsia::io2::FileSignal& other) const {
+ return ::llcpp::fuchsia::io2::FileSignal(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::FileSignal FileSignal::operator^(
+ const ::llcpp::fuchsia::io2::FileSignal& other) const {
+ return ::llcpp::fuchsia::io2::FileSignal(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void FileSignal::operator|=(
+ const ::llcpp::fuchsia::io2::FileSignal& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void FileSignal::operator&=(
+ const ::llcpp::fuchsia::io2::FileSignal& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void FileSignal::operator^=(
+ const ::llcpp::fuchsia::io2::FileSignal& other) {
+ this->value_ ^= other.value_;
+}
+
+struct FileInfo;
+struct Directory_Unlink_Response;
+struct Directory_Unlink_Result;
+struct Directory_Rename_Response;
+struct Directory_Rename_Result;
+struct Directory_Link_Response;
+struct Directory_Link_Result;
+struct DirectoryWatchOptions;
+class DirectoryWatchMask final {
+public:
+ constexpr DirectoryWatchMask() : value_(0u) {}
+ explicit constexpr DirectoryWatchMask(uint64_t value) : value_(value) {}
+ const static DirectoryWatchMask EXISTING;
+ const static DirectoryWatchMask IDLE;
+ const static DirectoryWatchMask ADDED;
+ const static DirectoryWatchMask REMOVED;
+ const static DirectoryWatchMask mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const DirectoryWatchMask& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const DirectoryWatchMask& other) const { return value_ != other.value_; }
+ constexpr inline DirectoryWatchMask operator~() const;
+ constexpr inline DirectoryWatchMask operator|(const DirectoryWatchMask& other) const;
+ constexpr inline DirectoryWatchMask operator&(const DirectoryWatchMask& other) const;
+ constexpr inline DirectoryWatchMask operator^(const DirectoryWatchMask& other) const;
+ constexpr inline void operator|=(const DirectoryWatchMask& other);
+ constexpr inline void operator&=(const DirectoryWatchMask& other);
+ constexpr inline void operator^=(const DirectoryWatchMask& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::EXISTING = ::llcpp::fuchsia::io2::DirectoryWatchMask(1u);
+constexpr const ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::IDLE = ::llcpp::fuchsia::io2::DirectoryWatchMask(2u);
+constexpr const ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::ADDED = ::llcpp::fuchsia::io2::DirectoryWatchMask(4u);
+constexpr const ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::REMOVED = ::llcpp::fuchsia::io2::DirectoryWatchMask(8u);
+constexpr const ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::mask = ::llcpp::fuchsia::io2::DirectoryWatchMask(15u);
+
+constexpr inline ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::operator~() const {
+ return ::llcpp::fuchsia::io2::DirectoryWatchMask(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::operator|(
+ const ::llcpp::fuchsia::io2::DirectoryWatchMask& other) const {
+ return ::llcpp::fuchsia::io2::DirectoryWatchMask(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::operator&(
+ const ::llcpp::fuchsia::io2::DirectoryWatchMask& other) const {
+ return ::llcpp::fuchsia::io2::DirectoryWatchMask(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::DirectoryWatchMask DirectoryWatchMask::operator^(
+ const ::llcpp::fuchsia::io2::DirectoryWatchMask& other) const {
+ return ::llcpp::fuchsia::io2::DirectoryWatchMask(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void DirectoryWatchMask::operator|=(
+ const ::llcpp::fuchsia::io2::DirectoryWatchMask& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void DirectoryWatchMask::operator&=(
+ const ::llcpp::fuchsia::io2::DirectoryWatchMask& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void DirectoryWatchMask::operator^=(
+ const ::llcpp::fuchsia::io2::DirectoryWatchMask& other) {
+ this->value_ ^= other.value_;
+}
+
+struct DirectoryInfo;
+struct DirectoryEnumerateOptions;
+class DeviceSignal final {
+public:
+ constexpr DeviceSignal() : value_(0u) {}
+ explicit constexpr DeviceSignal(uint32_t value) : value_(value) {}
+ const static DeviceSignal READABLE;
+ const static DeviceSignal WRITABLE;
+ const static DeviceSignal ERROR;
+ const static DeviceSignal HANGUP;
+ const static DeviceSignal OOB;
+ const static DeviceSignal mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const DeviceSignal& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const DeviceSignal& other) const { return value_ != other.value_; }
+ constexpr inline DeviceSignal operator~() const;
+ constexpr inline DeviceSignal operator|(const DeviceSignal& other) const;
+ constexpr inline DeviceSignal operator&(const DeviceSignal& other) const;
+ constexpr inline DeviceSignal operator^(const DeviceSignal& other) const;
+ constexpr inline void operator|=(const DeviceSignal& other);
+ constexpr inline void operator&=(const DeviceSignal& other);
+ constexpr inline void operator^=(const DeviceSignal& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::READABLE = ::llcpp::fuchsia::io2::DeviceSignal(16777216u);
+constexpr const ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::WRITABLE = ::llcpp::fuchsia::io2::DeviceSignal(33554432u);
+constexpr const ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::ERROR = ::llcpp::fuchsia::io2::DeviceSignal(67108864u);
+constexpr const ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::HANGUP = ::llcpp::fuchsia::io2::DeviceSignal(134217728u);
+constexpr const ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::OOB = ::llcpp::fuchsia::io2::DeviceSignal(268435456u);
+constexpr const ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::mask = ::llcpp::fuchsia::io2::DeviceSignal(520093696u);
+
+constexpr inline ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::operator~() const {
+ return ::llcpp::fuchsia::io2::DeviceSignal(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::operator|(
+ const ::llcpp::fuchsia::io2::DeviceSignal& other) const {
+ return ::llcpp::fuchsia::io2::DeviceSignal(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::operator&(
+ const ::llcpp::fuchsia::io2::DeviceSignal& other) const {
+ return ::llcpp::fuchsia::io2::DeviceSignal(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::DeviceSignal DeviceSignal::operator^(
+ const ::llcpp::fuchsia::io2::DeviceSignal& other) const {
+ return ::llcpp::fuchsia::io2::DeviceSignal(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void DeviceSignal::operator|=(
+ const ::llcpp::fuchsia::io2::DeviceSignal& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void DeviceSignal::operator&=(
+ const ::llcpp::fuchsia::io2::DeviceSignal& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void DeviceSignal::operator^=(
+ const ::llcpp::fuchsia::io2::DeviceSignal& other) {
+ this->value_ ^= other.value_;
+}
+
+struct DeviceInfo;
+struct DebuglogInfo;
+struct ConnectorInfo;
+struct Representation;
+struct ConnectionInfo;
+class ConnectionInfoQuery final {
+public:
+ constexpr ConnectionInfoQuery() : value_(0u) {}
+ explicit constexpr ConnectionInfoQuery(uint64_t value) : value_(value) {}
+ const static ConnectionInfoQuery REPRESENTATION;
+ const static ConnectionInfoQuery RIGHTS;
+ const static ConnectionInfoQuery AVAILABLE_OPERATIONS;
+ const static ConnectionInfoQuery mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const ConnectionInfoQuery& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const ConnectionInfoQuery& other) const { return value_ != other.value_; }
+ constexpr inline ConnectionInfoQuery operator~() const;
+ constexpr inline ConnectionInfoQuery operator|(const ConnectionInfoQuery& other) const;
+ constexpr inline ConnectionInfoQuery operator&(const ConnectionInfoQuery& other) const;
+ constexpr inline ConnectionInfoQuery operator^(const ConnectionInfoQuery& other) const;
+ constexpr inline void operator|=(const ConnectionInfoQuery& other);
+ constexpr inline void operator&=(const ConnectionInfoQuery& other);
+ constexpr inline void operator^=(const ConnectionInfoQuery& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::ConnectionInfoQuery ConnectionInfoQuery::REPRESENTATION = ::llcpp::fuchsia::io2::ConnectionInfoQuery(1u);
+constexpr const ::llcpp::fuchsia::io2::ConnectionInfoQuery ConnectionInfoQuery::RIGHTS = ::llcpp::fuchsia::io2::ConnectionInfoQuery(2u);
+constexpr const ::llcpp::fuchsia::io2::ConnectionInfoQuery ConnectionInfoQuery::AVAILABLE_OPERATIONS = ::llcpp::fuchsia::io2::ConnectionInfoQuery(4u);
+constexpr const ::llcpp::fuchsia::io2::ConnectionInfoQuery ConnectionInfoQuery::mask = ::llcpp::fuchsia::io2::ConnectionInfoQuery(7u);
+
+constexpr inline ::llcpp::fuchsia::io2::ConnectionInfoQuery ConnectionInfoQuery::operator~() const {
+ return ::llcpp::fuchsia::io2::ConnectionInfoQuery(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::ConnectionInfoQuery ConnectionInfoQuery::operator|(
+ const ::llcpp::fuchsia::io2::ConnectionInfoQuery& other) const {
+ return ::llcpp::fuchsia::io2::ConnectionInfoQuery(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::ConnectionInfoQuery ConnectionInfoQuery::operator&(
+ const ::llcpp::fuchsia::io2::ConnectionInfoQuery& other) const {
+ return ::llcpp::fuchsia::io2::ConnectionInfoQuery(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::ConnectionInfoQuery ConnectionInfoQuery::operator^(
+ const ::llcpp::fuchsia::io2::ConnectionInfoQuery& other) const {
+ return ::llcpp::fuchsia::io2::ConnectionInfoQuery(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void ConnectionInfoQuery::operator|=(
+ const ::llcpp::fuchsia::io2::ConnectionInfoQuery& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void ConnectionInfoQuery::operator&=(
+ const ::llcpp::fuchsia::io2::ConnectionInfoQuery& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void ConnectionInfoQuery::operator^=(
+ const ::llcpp::fuchsia::io2::ConnectionInfoQuery& other) {
+ this->value_ ^= other.value_;
+}
+
+class ConnectionFlags final {
+public:
+ constexpr ConnectionFlags() : value_(0u) {}
+ explicit constexpr ConnectionFlags(uint64_t value) : value_(value) {}
+ const static ConnectionFlags GET_CONNECTION_INFO;
+ const static ConnectionFlags CONNECT;
+ const static ConnectionFlags APPEND;
+ const static ConnectionFlags TRUNCATE;
+ const static ConnectionFlags mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const ConnectionFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const ConnectionFlags& other) const { return value_ != other.value_; }
+ constexpr inline ConnectionFlags operator~() const;
+ constexpr inline ConnectionFlags operator|(const ConnectionFlags& other) const;
+ constexpr inline ConnectionFlags operator&(const ConnectionFlags& other) const;
+ constexpr inline ConnectionFlags operator^(const ConnectionFlags& other) const;
+ constexpr inline void operator|=(const ConnectionFlags& other);
+ constexpr inline void operator&=(const ConnectionFlags& other);
+ constexpr inline void operator^=(const ConnectionFlags& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::GET_CONNECTION_INFO = ::llcpp::fuchsia::io2::ConnectionFlags(1u);
+constexpr const ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::CONNECT = ::llcpp::fuchsia::io2::ConnectionFlags(2u);
+constexpr const ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::APPEND = ::llcpp::fuchsia::io2::ConnectionFlags(4u);
+constexpr const ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::TRUNCATE = ::llcpp::fuchsia::io2::ConnectionFlags(8u);
+constexpr const ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::mask = ::llcpp::fuchsia::io2::ConnectionFlags(15u);
+
+constexpr inline ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::operator~() const {
+ return ::llcpp::fuchsia::io2::ConnectionFlags(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::operator|(
+ const ::llcpp::fuchsia::io2::ConnectionFlags& other) const {
+ return ::llcpp::fuchsia::io2::ConnectionFlags(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::operator&(
+ const ::llcpp::fuchsia::io2::ConnectionFlags& other) const {
+ return ::llcpp::fuchsia::io2::ConnectionFlags(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::io2::ConnectionFlags ConnectionFlags::operator^(
+ const ::llcpp::fuchsia::io2::ConnectionFlags& other) const {
+ return ::llcpp::fuchsia::io2::ConnectionFlags(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void ConnectionFlags::operator|=(
+ const ::llcpp::fuchsia::io2::ConnectionFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void ConnectionFlags::operator&=(
+ const ::llcpp::fuchsia::io2::ConnectionFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void ConnectionFlags::operator^=(
+ const ::llcpp::fuchsia::io2::ConnectionFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+struct ConnectionOptions;
+class Node;
+class Pipe;
+class Memory;
+class File;
+class Directory;
+class Debuglog;
+
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryInfoTable;
+
+// Auxiliary data for the memory object representation of a node.
+// The node is a file which is represented as a VMO.
+// The selection of this variant in [`Representation`] implies that the
+// connection speaks the [`fuchsia.io2/Memory`] protocol.
+struct MemoryInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Although a VMO is returned as a part of this structure, that VMO may
+ // back multiple files. To identify the logical portion of the VMO that
+ // represents the single file, offset and size are also supplied.
+ //
+ // If the range covers the entire VMO (i.e. the offset is zero and the
+ // length matches the size of the VMO), then all clients must receive a
+ // VMO with the same koid. This can be a duplicate of the same underlying
+ // page-aligned VMO.
+ //
+ // The rights on this VMO should correspond to the rights on the
+ // node connection.
+ const ::llcpp::fuchsia::mem::Range& buffer() const {
+ ZX_ASSERT(has_buffer());
+ return *reinterpret_cast<const ::llcpp::fuchsia::mem::Range*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::mem::Range& buffer() {
+ ZX_ASSERT(has_buffer());
+ return *reinterpret_cast<::llcpp::fuchsia::mem::Range*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_buffer() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ MemoryInfo() = default;
+ ~MemoryInfo() = default;
+ MemoryInfo(MemoryInfo&& other) noexcept = default;
+ MemoryInfo& operator=(MemoryInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 40;
+ static constexpr bool HasPointer = true;
+
+ private:
+ MemoryInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class MemoryInfo::Builder {
+ public:
+ MemoryInfo view() { return MemoryInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Although a VMO is returned as a part of this structure, that VMO may
+ // back multiple files. To identify the logical portion of the VMO that
+ // represents the single file, offset and size are also supplied.
+ //
+ // If the range covers the entire VMO (i.e. the offset is zero and the
+ // length matches the size of the VMO), then all clients must receive a
+ // VMO with the same koid. This can be a duplicate of the same underlying
+ // page-aligned VMO.
+ //
+ // The rights on this VMO should correspond to the rights on the
+ // node connection.
+ Builder&& set_buffer(::llcpp::fuchsia::mem::Range* elem);
+
+ private:
+ Builder() = default;
+ friend Builder MemoryInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_GetMemRange_ResultTable;
+
+struct File_GetMemRange_Result {
+ File_GetMemRange_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static File_GetMemRange_Result WithResponse(::llcpp::fuchsia::io2::File_GetMemRange_Response* val) {
+ File_GetMemRange_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::File_GetMemRange_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::File_GetMemRange_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_GetMemRange_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::File_GetMemRange_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_GetMemRange_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static File_GetMemRange_Result WithErr(int32_t* val) {
+ File_GetMemRange_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_GetMemRange_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_TtyInfoTable;
+
+// The object may be cast to a Tty interface.
+struct TtyInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // An optional event which transmits information about a device's state.
+ //
+ // The [`DeviceSignal`] values may be observed on this event.
+ const ::zx::eventpair& event() const {
+ ZX_ASSERT(has_event());
+ return *reinterpret_cast<const ::zx::eventpair*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::zx::eventpair& event() {
+ ZX_ASSERT(has_event());
+ return *reinterpret_cast<::zx::eventpair*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_event() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ TtyInfo() = default;
+ ~TtyInfo() = default;
+ TtyInfo(TtyInfo&& other) noexcept = default;
+ TtyInfo& operator=(TtyInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_TtyInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasPointer = true;
+
+ private:
+ TtyInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class TtyInfo::Builder {
+ public:
+ TtyInfo view() { return TtyInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // An optional event which transmits information about a device's state.
+ //
+ // The [`DeviceSignal`] values may be observed on this event.
+ Builder&& set_event(::zx::eventpair* elem);
+
+ private:
+ Builder() = default;
+ friend Builder TtyInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_Read_ResultTable;
+
+struct File_Read_Result {
+ File_Read_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static File_Read_Result WithResponse(::llcpp::fuchsia::io2::File_Read_Response* val) {
+ File_Read_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::File_Read_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::File_Read_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_Read_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::File_Read_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_Read_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static File_Read_Result WithErr(int32_t* val) {
+ File_Read_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_Read_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8208;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_ReadAt_ResultTable;
+
+struct File_ReadAt_Result {
+ File_ReadAt_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static File_ReadAt_Result WithResponse(::llcpp::fuchsia::io2::File_ReadAt_Response* val) {
+ File_ReadAt_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::File_ReadAt_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::File_ReadAt_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_ReadAt_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::File_ReadAt_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_ReadAt_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static File_ReadAt_Result WithErr(int32_t* val) {
+ File_ReadAt_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_ReadAt_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8208;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Node_GetToken_ResultTable;
+
+struct Node_GetToken_Result {
+ Node_GetToken_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Node_GetToken_Result WithResponse(::llcpp::fuchsia::io2::Node_GetToken_Response* val) {
+ Node_GetToken_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::Node_GetToken_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::Node_GetToken_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Node_GetToken_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::Node_GetToken_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Node_GetToken_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Node_GetToken_Result WithErr(int32_t* val) {
+ Node_GetToken_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Node_GetToken_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_PosixSocketInfoTable;
+
+// Auxiliary data for the POSIX socket representation of a node.
+// The selection of this variant in [`Representation`] implies that the
+// connection speaks the [`fuchsia.posix.socket/Control`] protocol.
+struct PosixSocketInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The backing transport for the socket.
+ // The rights on this socket should correspond to the rights on the
+ // node connection.
+ const ::zx::socket& socket() const {
+ ZX_ASSERT(has_socket());
+ return *reinterpret_cast<const ::zx::socket*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::zx::socket& socket() {
+ ZX_ASSERT(has_socket());
+ return *reinterpret_cast<::zx::socket*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_socket() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ PosixSocketInfo() = default;
+ ~PosixSocketInfo() = default;
+ PosixSocketInfo(PosixSocketInfo&& other) noexcept = default;
+ PosixSocketInfo& operator=(PosixSocketInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PosixSocketInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasPointer = true;
+
+ private:
+ PosixSocketInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class PosixSocketInfo::Builder {
+ public:
+ PosixSocketInfo view() { return PosixSocketInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The backing transport for the socket.
+ // The rights on this socket should correspond to the rights on the
+ // node connection.
+ Builder&& set_socket(::zx::socket* elem);
+
+ private:
+ Builder() = default;
+ friend Builder PosixSocketInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeInfoTable;
+
+// The pipe representation of a node.
+// A pipe is a data streaming interface, commonly used for standard in/out.
+// There is no universal requirement as to if it is uni- or bi-directional.
+// The selection of this variant in [`Representation`] implies that the
+// connection speaks the [`fuchsia.io2/Pipe`] protocol.
+struct PipeInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The backing socket transport for the pipe.
+ // The rights on this socket should correspond to the rights on the
+ // node connection.
+ const ::zx::socket& socket() const {
+ ZX_ASSERT(has_socket());
+ return *reinterpret_cast<const ::zx::socket*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::zx::socket& socket() {
+ ZX_ASSERT(has_socket());
+ return *reinterpret_cast<::zx::socket*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_socket() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ PipeInfo() = default;
+ ~PipeInfo() = default;
+ PipeInfo(PipeInfo&& other) noexcept = default;
+ PipeInfo& operator=(PipeInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasPointer = true;
+
+ private:
+ PipeInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class PipeInfo::Builder {
+ public:
+ PipeInfo view() { return PipeInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The backing socket transport for the pipe.
+ // The rights on this socket should correspond to the rights on the
+ // node connection.
+ Builder&& set_socket(::zx::socket* elem);
+
+ private:
+ Builder() = default;
+ friend Builder PipeInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Node_UpdateAttributes_ResultTable;
+
+struct Node_UpdateAttributes_Result {
+ Node_UpdateAttributes_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Node_UpdateAttributes_Result WithResponse(::llcpp::fuchsia::io2::Node_UpdateAttributes_Response* val) {
+ Node_UpdateAttributes_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::Node_UpdateAttributes_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::Node_UpdateAttributes_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Node_UpdateAttributes_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::Node_UpdateAttributes_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Node_UpdateAttributes_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Node_UpdateAttributes_Result WithErr(int32_t* val) {
+ Node_UpdateAttributes_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Node_UpdateAttributes_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Node_Sync_ResultTable;
+
+struct Node_Sync_Result {
+ Node_Sync_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Node_Sync_Result WithResponse(::llcpp::fuchsia::io2::Node_Sync_Response* val) {
+ Node_Sync_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::Node_Sync_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::Node_Sync_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Node_Sync_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::Node_Sync_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Node_Sync_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Node_Sync_Result WithErr(int32_t* val) {
+ Node_Sync_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Node_Sync_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeAttributesTable;
+
+// Objective information about a filesystem node.
+// See [`Node.GetAttributes`] and [`Node.UpdateAttributes`].
+//
+// The attributes of a node should be stable, independent of the
+// specific protocol used to access it.
+//
+// If a particular attribute is not applicable or not supported,
+// filesystems should leave the corresponding field absent.
+struct NodeAttributes final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Describes the kinds of representations supported by the node.
+ // Note: This is not the result of the connection-time negotiation,
+ // which is conveyed via `representation`.
+ //
+ // This attribute is read-only.
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& protocols() const {
+ ZX_ASSERT(has_protocols());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::NodeProtocolSet*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::NodeProtocolSet& protocols() {
+ ZX_ASSERT(has_protocols());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::NodeProtocolSet*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_protocols() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Describes the kinds of operations supported by the node.
+ // Note: This is distinct from the rights used at connection time.
+ //
+ // This attribute is read-only.
+ const ::llcpp::fuchsia::io2::Operations& abilities() const {
+ ZX_ASSERT(has_abilities());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::Operations& abilities() {
+ ZX_ASSERT(has_abilities());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_abilities() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // Node size, in bytes.
+ //
+ // This attribute is read-only.
+ const uint64_t& content_size() const {
+ ZX_ASSERT(has_content_size());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ uint64_t& content_size() {
+ ZX_ASSERT(has_content_size());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_content_size() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // Space needed to store the node (possibly larger than size), in bytes.
+ //
+ // This attribute is read-only.
+ const uint64_t& storage_size() const {
+ ZX_ASSERT(has_storage_size());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ uint64_t& storage_size() {
+ ZX_ASSERT(has_storage_size());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_storage_size() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ // Number of hard links to the node. It must be at least one.
+ //
+ // This attribute is read-only.
+ const uint64_t& link_count() const {
+ ZX_ASSERT(has_link_count());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ uint64_t& link_count() {
+ ZX_ASSERT(has_link_count());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_link_count() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ // Time of creation in nanoseconds since the Unix epoch, UTC.
+ // It may be updated manually after creation.
+ const uint64_t& creation_time() const {
+ ZX_ASSERT(has_creation_time());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(6 - 1).data);
+ }
+ uint64_t& creation_time() {
+ ZX_ASSERT(has_creation_time());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(6 - 1).data);
+ }
+ bool has_creation_time() const {
+ return EnvelopesView::count() >= 6 && EnvelopesView::at(6 - 1).data != nullptr;
+ }
+
+ // Time of last modification in nanoseconds since the Unix epoch, UTC.
+ const uint64_t& modification_time() const {
+ ZX_ASSERT(has_modification_time());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(7 - 1).data);
+ }
+ uint64_t& modification_time() {
+ ZX_ASSERT(has_modification_time());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(7 - 1).data);
+ }
+ bool has_modification_time() const {
+ return EnvelopesView::count() >= 7 && EnvelopesView::at(7 - 1).data != nullptr;
+ }
+
+ // An ID for the node. See [`fuchsia.io2/Id`].
+ // This `id` should be unique among all entries of a directory.
+ //
+ // This attribute is read-only.
+ const uint64_t& id() const {
+ ZX_ASSERT(has_id());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(8 - 1).data);
+ }
+ uint64_t& id() {
+ ZX_ASSERT(has_id());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(8 - 1).data);
+ }
+ bool has_id() const {
+ return EnvelopesView::count() >= 8 && EnvelopesView::at(8 - 1).data != nullptr;
+ }
+
+ NodeAttributes() = default;
+ ~NodeAttributes() = default;
+ NodeAttributes(NodeAttributes&& other) noexcept = default;
+ NodeAttributes& operator=(NodeAttributes&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeAttributesTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 192;
+ static constexpr bool HasPointer = true;
+
+ private:
+ NodeAttributes(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class NodeAttributes::Builder {
+ public:
+ NodeAttributes view() { return NodeAttributes(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Describes the kinds of representations supported by the node.
+ // Note: This is not the result of the connection-time negotiation,
+ // which is conveyed via `representation`.
+ //
+ // This attribute is read-only.
+ Builder&& set_protocols(::llcpp::fuchsia::io2::NodeProtocolSet* elem);
+
+ // Describes the kinds of operations supported by the node.
+ // Note: This is distinct from the rights used at connection time.
+ //
+ // This attribute is read-only.
+ Builder&& set_abilities(::llcpp::fuchsia::io2::Operations* elem);
+
+ // Node size, in bytes.
+ //
+ // This attribute is read-only.
+ Builder&& set_content_size(uint64_t* elem);
+
+ // Space needed to store the node (possibly larger than size), in bytes.
+ //
+ // This attribute is read-only.
+ Builder&& set_storage_size(uint64_t* elem);
+
+ // Number of hard links to the node. It must be at least one.
+ //
+ // This attribute is read-only.
+ Builder&& set_link_count(uint64_t* elem);
+
+ // Time of creation in nanoseconds since the Unix epoch, UTC.
+ // It may be updated manually after creation.
+ Builder&& set_creation_time(uint64_t* elem);
+
+ // Time of last modification in nanoseconds since the Unix epoch, UTC.
+ Builder&& set_modification_time(uint64_t* elem);
+
+ // An ID for the node. See [`fuchsia.io2/Id`].
+ // This `id` should be unique among all entries of a directory.
+ //
+ // This attribute is read-only.
+ Builder&& set_id(uint64_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder NodeAttributes::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 8> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Node_GetAttributes_ResultTable;
+
+struct Node_GetAttributes_Result {
+ Node_GetAttributes_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Node_GetAttributes_Result WithResponse(::llcpp::fuchsia::io2::Node_GetAttributes_Response* val) {
+ Node_GetAttributes_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::Node_GetAttributes_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::Node_GetAttributes_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Node_GetAttributes_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::Node_GetAttributes_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Node_GetAttributes_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Node_GetAttributes_Result WithErr(int32_t* val) {
+ Node_GetAttributes_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Node_GetAttributes_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 208;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryEntryTable;
+
+// Information about an immediate child node of a directory.
+//
+// If a particular attribute is not applicable or not supported,
+// implementations should leave the corresponding field absent.
+struct DirectoryEntry final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Name of the node. This field must be present.
+ const ::fidl::StringView& name() const {
+ ZX_ASSERT(has_name());
+ return *reinterpret_cast<const ::fidl::StringView*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::fidl::StringView& name() {
+ ZX_ASSERT(has_name());
+ return *reinterpret_cast<::fidl::StringView*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_name() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Describes the kinds of representations supported by the node.
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& protocols() const {
+ ZX_ASSERT(has_protocols());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::NodeProtocolSet*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::NodeProtocolSet& protocols() {
+ ZX_ASSERT(has_protocols());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::NodeProtocolSet*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_protocols() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // Describes the kinds of operations supported by the node.
+ const ::llcpp::fuchsia::io2::Operations& abilities() const {
+ ZX_ASSERT(has_abilities());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::Operations& abilities() {
+ ZX_ASSERT(has_abilities());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_abilities() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // An ID for the node. See [`fuchsia.io2/Id`].
+ // This `id` should be unique among all entries of a directory.
+ const uint64_t& id() const {
+ ZX_ASSERT(has_id());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ uint64_t& id() {
+ ZX_ASSERT(has_id());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_id() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ DirectoryEntry() = default;
+ ~DirectoryEntry() = default;
+ DirectoryEntry(DirectoryEntry&& other) noexcept = default;
+ DirectoryEntry& operator=(DirectoryEntry&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryEntryTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 360;
+ static constexpr bool HasPointer = true;
+
+ private:
+ DirectoryEntry(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class DirectoryEntry::Builder {
+ public:
+ DirectoryEntry view() { return DirectoryEntry(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Name of the node. This field must be present.
+ Builder&& set_name(::fidl::StringView* elem);
+
+ // Describes the kinds of representations supported by the node.
+ Builder&& set_protocols(::llcpp::fuchsia::io2::NodeProtocolSet* elem);
+
+ // Describes the kinds of operations supported by the node.
+ Builder&& set_abilities(::llcpp::fuchsia::io2::Operations* elem);
+
+ // An ID for the node. See [`fuchsia.io2/Id`].
+ // This `id` should be unique among all entries of a directory.
+ Builder&& set_id(uint64_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder DirectoryEntry::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 4> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatchedEventTable;
+
+// Events returned from [`DirectoryWatcher.GetNext`].
+struct DirectoryWatchedEvent {
+ DirectoryWatchedEvent() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kExisting = 1, // 0x1
+ kIdle = 2, // 0x2
+ kAdded = 3, // 0x3
+ kRemoved = 4, // 0x4
+ kUnknown = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_existing() const { return ordinal() == Ordinal::kExisting; }
+
+ static DirectoryWatchedEvent WithExisting(::llcpp::fuchsia::io2::DirectoryEntry* val) {
+ DirectoryWatchedEvent result;
+ result.set_existing(val);
+ return result;
+ }
+
+ // Indicates a node already existed in the directory when watching started.
+ void set_existing(::llcpp::fuchsia::io2::DirectoryEntry* elem) {
+ ordinal_ = Ordinal::kExisting;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Indicates a node already existed in the directory when watching started.
+ ::llcpp::fuchsia::io2::DirectoryEntry& mutable_existing() {
+ ZX_ASSERT(ordinal() == Ordinal::kExisting);
+ return *static_cast<::llcpp::fuchsia::io2::DirectoryEntry*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::DirectoryEntry& existing() const {
+ ZX_ASSERT(ordinal() == Ordinal::kExisting);
+ return *static_cast<::llcpp::fuchsia::io2::DirectoryEntry*>(envelope_.data);
+ }
+
+ bool is_idle() const { return ordinal() == Ordinal::kIdle; }
+
+ static DirectoryWatchedEvent WithIdle(::llcpp::fuchsia::io2::IdleEvent* val) {
+ DirectoryWatchedEvent result;
+ result.set_idle(val);
+ return result;
+ }
+
+ // Indicates that no more `existing` events will be sent.
+ void set_idle(::llcpp::fuchsia::io2::IdleEvent* elem) {
+ ordinal_ = Ordinal::kIdle;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Indicates that no more `existing` events will be sent.
+ ::llcpp::fuchsia::io2::IdleEvent& mutable_idle() {
+ ZX_ASSERT(ordinal() == Ordinal::kIdle);
+ return *static_cast<::llcpp::fuchsia::io2::IdleEvent*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::IdleEvent& idle() const {
+ ZX_ASSERT(ordinal() == Ordinal::kIdle);
+ return *static_cast<::llcpp::fuchsia::io2::IdleEvent*>(envelope_.data);
+ }
+
+ bool is_added() const { return ordinal() == Ordinal::kAdded; }
+
+ static DirectoryWatchedEvent WithAdded(::llcpp::fuchsia::io2::DirectoryEntry* val) {
+ DirectoryWatchedEvent result;
+ result.set_added(val);
+ return result;
+ }
+
+ // Indicates a node has been created (either new or moved) into a
+ // directory.
+ void set_added(::llcpp::fuchsia::io2::DirectoryEntry* elem) {
+ ordinal_ = Ordinal::kAdded;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Indicates a node has been created (either new or moved) into a
+ // directory.
+ ::llcpp::fuchsia::io2::DirectoryEntry& mutable_added() {
+ ZX_ASSERT(ordinal() == Ordinal::kAdded);
+ return *static_cast<::llcpp::fuchsia::io2::DirectoryEntry*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::DirectoryEntry& added() const {
+ ZX_ASSERT(ordinal() == Ordinal::kAdded);
+ return *static_cast<::llcpp::fuchsia::io2::DirectoryEntry*>(envelope_.data);
+ }
+
+ bool is_removed() const { return ordinal() == Ordinal::kRemoved; }
+
+ static DirectoryWatchedEvent WithRemoved(::fidl::StringView* val) {
+ DirectoryWatchedEvent result;
+ result.set_removed(val);
+ return result;
+ }
+
+ // Indicates a node has been removed (either deleted or moved) from the
+ // directory.
+ void set_removed(::fidl::StringView* elem) {
+ ordinal_ = Ordinal::kRemoved;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Indicates a node has been removed (either deleted or moved) from the
+ // directory.
+ ::fidl::StringView& mutable_removed() {
+ ZX_ASSERT(ordinal() == Ordinal::kRemoved);
+ return *static_cast<::fidl::StringView*>(envelope_.data);
+ }
+ const ::fidl::StringView& removed() const {
+ ZX_ASSERT(ordinal() == Ordinal::kRemoved);
+ return *static_cast<::fidl::StringView*>(envelope_.data);
+ }
+ void* unknownData() const {
+ ZX_ASSERT(which() == Tag::kUnknown);
+ return envelope_.data;
+ }
+ Tag which() const;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryWatchedEventTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 376;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kExisting = 1, // 0x1
+ kIdle = 2, // 0x2
+ kAdded = 3, // 0x3
+ kRemoved = 4, // 0x4
+ };
+
+ Ordinal ordinal() const {
+ switch (static_cast<fidl_xunion_tag_t>(ordinal_)) {
+ case 1:
+ case 1263581438:
+ return Ordinal::kExisting;
+ case 2:
+ case 1234379794:
+ return Ordinal::kIdle;
+ case 3:
+ case 1712492072:
+ return Ordinal::kAdded;
+ case 4:
+ case 91294460:
+ return Ordinal::kRemoved;
+ }
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryIterator_GetNext_ResultTable;
+
+struct DirectoryIterator_GetNext_Result {
+ DirectoryIterator_GetNext_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static DirectoryIterator_GetNext_Result WithResponse(::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response* val) {
+ DirectoryIterator_GetNext_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static DirectoryIterator_GetNext_Result WithErr(int32_t* val) {
+ DirectoryIterator_GetNext_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryIterator_GetNext_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 3080208;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_Write_ResultTable;
+
+struct File_Write_Result {
+ File_Write_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static File_Write_Result WithResponse(::llcpp::fuchsia::io2::File_Write_Response* val) {
+ File_Write_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::File_Write_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::File_Write_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_Write_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::File_Write_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_Write_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static File_Write_Result WithErr(int32_t* val) {
+ File_Write_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_Write_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_WriteAt_ResultTable;
+
+struct File_WriteAt_Result {
+ File_WriteAt_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static File_WriteAt_Result WithResponse(::llcpp::fuchsia::io2::File_WriteAt_Response* val) {
+ File_WriteAt_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::File_WriteAt_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::File_WriteAt_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_WriteAt_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::File_WriteAt_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_WriteAt_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static File_WriteAt_Result WithErr(int32_t* val) {
+ File_WriteAt_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_WriteAt_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_Seek_ResultTable;
+
+struct File_Seek_Result {
+ File_Seek_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static File_Seek_Result WithResponse(::llcpp::fuchsia::io2::File_Seek_Response* val) {
+ File_Seek_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::File_Seek_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::File_Seek_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_Seek_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::File_Seek_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_Seek_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static File_Seek_Result WithErr(int32_t* val) {
+ File_Seek_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_Seek_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_Resize_ResultTable;
+
+struct File_Resize_Result {
+ File_Resize_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static File_Resize_Result WithResponse(::llcpp::fuchsia::io2::File_Resize_Response* val) {
+ File_Resize_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::File_Resize_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::File_Resize_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_Resize_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::File_Resize_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::File_Resize_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static File_Resize_Result WithErr(int32_t* val) {
+ File_Resize_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_Resize_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_FileInfoTable;
+
+// Auxiliary data for the file representation of a node.
+// The selection of this variant in [`Representation`] implies that the
+// connection speaks the [`fuchsia.io2/File`] protocol.
+struct FileInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // An optional event which transmits information about an object's
+ // readability or writability. This event relays information about the
+ // underlying object, not the capability granted to client: this event
+ // may be signalled "readable" on a connection that does not have
+ // the capability to read.
+ //
+ // This event will be present if the following conditions are met:
+ //
+ // - The `available_operations` on the file connection is not empty.
+ // - The filesystem supports signalling readability/writability events.
+ //
+ // The [`FileSignal`] values may be observed on this event.
+ const ::zx::event& observer() const {
+ ZX_ASSERT(has_observer());
+ return *reinterpret_cast<const ::zx::event*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::zx::event& observer() {
+ ZX_ASSERT(has_observer());
+ return *reinterpret_cast<::zx::event*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_observer() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Returns if the file is opened in append mode.
+ // In append mode, the seek offset is moved to the end before every
+ // write, the two steps performed in an atomic manner.
+ const bool& is_append() const {
+ ZX_ASSERT(has_is_append());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool& is_append() {
+ ZX_ASSERT(has_is_append());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_is_append() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ FileInfo() = default;
+ ~FileInfo() = default;
+ FileInfo(FileInfo&& other) noexcept = default;
+ FileInfo& operator=(FileInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 48;
+ static constexpr bool HasPointer = true;
+
+ private:
+ FileInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class FileInfo::Builder {
+ public:
+ FileInfo view() { return FileInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // An optional event which transmits information about an object's
+ // readability or writability. This event relays information about the
+ // underlying object, not the capability granted to client: this event
+ // may be signalled "readable" on a connection that does not have
+ // the capability to read.
+ //
+ // This event will be present if the following conditions are met:
+ //
+ // - The `available_operations` on the file connection is not empty.
+ // - The filesystem supports signalling readability/writability events.
+ //
+ // The [`FileSignal`] values may be observed on this event.
+ Builder&& set_observer(::zx::event* elem);
+
+ // Returns if the file is opened in append mode.
+ // In append mode, the seek offset is moved to the end before every
+ // write, the two steps performed in an atomic manner.
+ Builder&& set_is_append(bool* elem);
+
+ private:
+ Builder() = default;
+ friend Builder FileInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 2> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Directory_Unlink_ResultTable;
+
+struct Directory_Unlink_Result {
+ Directory_Unlink_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Directory_Unlink_Result WithResponse(::llcpp::fuchsia::io2::Directory_Unlink_Response* val) {
+ Directory_Unlink_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::Directory_Unlink_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::Directory_Unlink_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Directory_Unlink_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::Directory_Unlink_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Directory_Unlink_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Directory_Unlink_Result WithErr(int32_t* val) {
+ Directory_Unlink_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Directory_Unlink_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Directory_Rename_ResultTable;
+
+struct Directory_Rename_Result {
+ Directory_Rename_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Directory_Rename_Result WithResponse(::llcpp::fuchsia::io2::Directory_Rename_Response* val) {
+ Directory_Rename_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::Directory_Rename_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::Directory_Rename_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Directory_Rename_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::Directory_Rename_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Directory_Rename_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Directory_Rename_Result WithErr(int32_t* val) {
+ Directory_Rename_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Directory_Rename_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Directory_Link_ResultTable;
+
+struct Directory_Link_Result {
+ Directory_Link_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Directory_Link_Result WithResponse(::llcpp::fuchsia::io2::Directory_Link_Response* val) {
+ Directory_Link_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::io2::Directory_Link_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::Directory_Link_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Directory_Link_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::Directory_Link_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::io2::Directory_Link_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Directory_Link_Result WithErr(int32_t* val) {
+ Directory_Link_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Directory_Link_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatchOptionsTable;
+
+struct DirectoryWatchOptions final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ DirectoryWatchOptions() = default;
+ ~DirectoryWatchOptions() = default;
+ DirectoryWatchOptions(DirectoryWatchOptions&& other) noexcept = default;
+ DirectoryWatchOptions& operator=(DirectoryWatchOptions&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryWatchOptionsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = true;
+
+ private:
+ DirectoryWatchOptions(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class DirectoryWatchOptions::Builder {
+ public:
+ DirectoryWatchOptions view() { return DirectoryWatchOptions(0, nullptr); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ private:
+ Builder() = default;
+ friend Builder DirectoryWatchOptions::Build();
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryInfoTable;
+
+// Auxiliary data for the directory representation of a node.
+// The selection of this variant in [`Representation`] implies that the
+// connection speaks the [`fuchsia.io2/Directory`] protocol.
+struct DirectoryInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ DirectoryInfo() = default;
+ ~DirectoryInfo() = default;
+ DirectoryInfo(DirectoryInfo&& other) noexcept = default;
+ DirectoryInfo& operator=(DirectoryInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = true;
+
+ private:
+ DirectoryInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class DirectoryInfo::Builder {
+ public:
+ DirectoryInfo view() { return DirectoryInfo(0, nullptr); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ private:
+ Builder() = default;
+ friend Builder DirectoryInfo::Build();
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryEnumerateOptionsTable;
+
+// Options to pass to [`fuchsia.io2/Directory.Enumerate`].
+struct DirectoryEnumerateOptions final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ DirectoryEnumerateOptions() = default;
+ ~DirectoryEnumerateOptions() = default;
+ DirectoryEnumerateOptions(DirectoryEnumerateOptions&& other) noexcept = default;
+ DirectoryEnumerateOptions& operator=(DirectoryEnumerateOptions&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryEnumerateOptionsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = true;
+
+ private:
+ DirectoryEnumerateOptions(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class DirectoryEnumerateOptions::Builder {
+ public:
+ DirectoryEnumerateOptions view() { return DirectoryEnumerateOptions(0, nullptr); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ private:
+ Builder() = default;
+ friend Builder DirectoryEnumerateOptions::Build();
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DeviceInfoTable;
+
+// The object may be cast to the shared interface of devices.
+struct DeviceInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // An optional event which transmits information about a device's state.
+ //
+ // The [`DeviceSignal`] values may be observed on this event.
+ const ::zx::eventpair& event() const {
+ ZX_ASSERT(has_event());
+ return *reinterpret_cast<const ::zx::eventpair*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::zx::eventpair& event() {
+ ZX_ASSERT(has_event());
+ return *reinterpret_cast<::zx::eventpair*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_event() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ DeviceInfo() = default;
+ ~DeviceInfo() = default;
+ DeviceInfo(DeviceInfo&& other) noexcept = default;
+ DeviceInfo& operator=(DeviceInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DeviceInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasPointer = true;
+
+ private:
+ DeviceInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class DeviceInfo::Builder {
+ public:
+ DeviceInfo view() { return DeviceInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // An optional event which transmits information about a device's state.
+ //
+ // The [`DeviceSignal`] values may be observed on this event.
+ Builder&& set_event(::zx::eventpair* elem);
+
+ private:
+ Builder() = default;
+ friend Builder DeviceInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogInfoTable;
+
+// The debuglog representation of a node.
+// The selection of this variant in [`Representation`] implies that the
+// connection speaks the [`fuchsia.io2/Debuglog`] protocol.
+struct DebuglogInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The backing debuglog kernel object.
+ const ::zx::debuglog& debuglog() const {
+ ZX_ASSERT(has_debuglog());
+ return *reinterpret_cast<const ::zx::debuglog*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::zx::debuglog& debuglog() {
+ ZX_ASSERT(has_debuglog());
+ return *reinterpret_cast<::zx::debuglog*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_debuglog() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ DebuglogInfo() = default;
+ ~DebuglogInfo() = default;
+ DebuglogInfo(DebuglogInfo&& other) noexcept = default;
+ DebuglogInfo& operator=(DebuglogInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasPointer = true;
+
+ private:
+ DebuglogInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class DebuglogInfo::Builder {
+ public:
+ DebuglogInfo view() { return DebuglogInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The backing debuglog kernel object.
+ Builder&& set_debuglog(::zx::debuglog* elem);
+
+ private:
+ Builder() = default;
+ friend Builder DebuglogInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 1> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_ConnectorInfoTable;
+
+// Auxiliary data for the connector representation of a node, used for
+// protocol discovery and connection.
+//
+// It supports connecting to arbitrary protocols exported by the filesystem
+// server at a path, including ones that do not compose [`fuchsia.io2/Node`].
+struct ConnectorInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ ConnectorInfo() = default;
+ ~ConnectorInfo() = default;
+ ConnectorInfo(ConnectorInfo&& other) noexcept = default;
+ ConnectorInfo& operator=(ConnectorInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_ConnectorInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = true;
+
+ private:
+ ConnectorInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class ConnectorInfo::Builder {
+ public:
+ ConnectorInfo view() { return ConnectorInfo(0, nullptr); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ private:
+ Builder() = default;
+ friend Builder ConnectorInfo::Build();
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_RepresentationTable;
+
+// Describes how the connection should be handled, and provides auxiliary
+// handles and information for the connection where applicable.
+// Refer to [`Node.Describe`] and [`Node.OnConnectionInfo`].
+//
+// If handles are returned which offer alternative ways of access to the node,
+// the rights on the handles should correspond to the rights on the connection.
+//
+// If the client specified more than one protocol in `protocols` during
+// [`Directory.Open`] or [`Node.Reopen`], the [`Representation`] xunion carries
+// additionally the result of the connection-time negotiation via its tag.
+//
+// The elements have one-to-one correspondence with the members of
+// [`NodeProtocolSet`].
+struct Representation {
+ Representation() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kConnector = 1, // 0x1
+ kDirectory = 2, // 0x2
+ kFile = 3, // 0x3
+ kMemory = 4, // 0x4
+ kPosixSocket = 5, // 0x5
+ kPipe = 6, // 0x6
+ kDebuglog = 7, // 0x7
+ kDevice = 8, // 0x8
+ kTty = 9, // 0x9
+ kUnknown = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_connector() const { return ordinal() == Ordinal::kConnector; }
+
+ static Representation WithConnector(::llcpp::fuchsia::io2::ConnectorInfo* val) {
+ Representation result;
+ result.set_connector(val);
+ return result;
+ }
+
+ // See [`NodeProtocolSet.CONNECTOR`].
+ void set_connector(::llcpp::fuchsia::io2::ConnectorInfo* elem) {
+ ordinal_ = Ordinal::kConnector;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // See [`NodeProtocolSet.CONNECTOR`].
+ ::llcpp::fuchsia::io2::ConnectorInfo& mutable_connector() {
+ ZX_ASSERT(ordinal() == Ordinal::kConnector);
+ return *static_cast<::llcpp::fuchsia::io2::ConnectorInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::ConnectorInfo& connector() const {
+ ZX_ASSERT(ordinal() == Ordinal::kConnector);
+ return *static_cast<::llcpp::fuchsia::io2::ConnectorInfo*>(envelope_.data);
+ }
+
+ bool is_directory() const { return ordinal() == Ordinal::kDirectory; }
+
+ static Representation WithDirectory(::llcpp::fuchsia::io2::DirectoryInfo* val) {
+ Representation result;
+ result.set_directory(val);
+ return result;
+ }
+
+ // See [`NodeProtocolSet.DIRECTORY`].
+ void set_directory(::llcpp::fuchsia::io2::DirectoryInfo* elem) {
+ ordinal_ = Ordinal::kDirectory;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // See [`NodeProtocolSet.DIRECTORY`].
+ ::llcpp::fuchsia::io2::DirectoryInfo& mutable_directory() {
+ ZX_ASSERT(ordinal() == Ordinal::kDirectory);
+ return *static_cast<::llcpp::fuchsia::io2::DirectoryInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::DirectoryInfo& directory() const {
+ ZX_ASSERT(ordinal() == Ordinal::kDirectory);
+ return *static_cast<::llcpp::fuchsia::io2::DirectoryInfo*>(envelope_.data);
+ }
+
+ bool is_file() const { return ordinal() == Ordinal::kFile; }
+
+ static Representation WithFile(::llcpp::fuchsia::io2::FileInfo* val) {
+ Representation result;
+ result.set_file(val);
+ return result;
+ }
+
+ // See [`NodeProtocolSet.FILE`].
+ void set_file(::llcpp::fuchsia::io2::FileInfo* elem) {
+ ordinal_ = Ordinal::kFile;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // See [`NodeProtocolSet.FILE`].
+ ::llcpp::fuchsia::io2::FileInfo& mutable_file() {
+ ZX_ASSERT(ordinal() == Ordinal::kFile);
+ return *static_cast<::llcpp::fuchsia::io2::FileInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::FileInfo& file() const {
+ ZX_ASSERT(ordinal() == Ordinal::kFile);
+ return *static_cast<::llcpp::fuchsia::io2::FileInfo*>(envelope_.data);
+ }
+
+ bool is_memory() const { return ordinal() == Ordinal::kMemory; }
+
+ static Representation WithMemory(::llcpp::fuchsia::io2::MemoryInfo* val) {
+ Representation result;
+ result.set_memory(val);
+ return result;
+ }
+
+ // See [`NodeProtocolSet.MEMORY`].
+ void set_memory(::llcpp::fuchsia::io2::MemoryInfo* elem) {
+ ordinal_ = Ordinal::kMemory;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // See [`NodeProtocolSet.MEMORY`].
+ ::llcpp::fuchsia::io2::MemoryInfo& mutable_memory() {
+ ZX_ASSERT(ordinal() == Ordinal::kMemory);
+ return *static_cast<::llcpp::fuchsia::io2::MemoryInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::MemoryInfo& memory() const {
+ ZX_ASSERT(ordinal() == Ordinal::kMemory);
+ return *static_cast<::llcpp::fuchsia::io2::MemoryInfo*>(envelope_.data);
+ }
+
+ bool is_posix_socket() const { return ordinal() == Ordinal::kPosixSocket; }
+
+ static Representation WithPosixSocket(::llcpp::fuchsia::io2::PosixSocketInfo* val) {
+ Representation result;
+ result.set_posix_socket(val);
+ return result;
+ }
+
+ // See [`NodeProtocolSet.POSIX_SOCKET`].
+ void set_posix_socket(::llcpp::fuchsia::io2::PosixSocketInfo* elem) {
+ ordinal_ = Ordinal::kPosixSocket;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // See [`NodeProtocolSet.POSIX_SOCKET`].
+ ::llcpp::fuchsia::io2::PosixSocketInfo& mutable_posix_socket() {
+ ZX_ASSERT(ordinal() == Ordinal::kPosixSocket);
+ return *static_cast<::llcpp::fuchsia::io2::PosixSocketInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::PosixSocketInfo& posix_socket() const {
+ ZX_ASSERT(ordinal() == Ordinal::kPosixSocket);
+ return *static_cast<::llcpp::fuchsia::io2::PosixSocketInfo*>(envelope_.data);
+ }
+
+ bool is_pipe() const { return ordinal() == Ordinal::kPipe; }
+
+ static Representation WithPipe(::llcpp::fuchsia::io2::PipeInfo* val) {
+ Representation result;
+ result.set_pipe(val);
+ return result;
+ }
+
+ // See [`NodeProtocolSet.PIPE`].
+ void set_pipe(::llcpp::fuchsia::io2::PipeInfo* elem) {
+ ordinal_ = Ordinal::kPipe;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // See [`NodeProtocolSet.PIPE`].
+ ::llcpp::fuchsia::io2::PipeInfo& mutable_pipe() {
+ ZX_ASSERT(ordinal() == Ordinal::kPipe);
+ return *static_cast<::llcpp::fuchsia::io2::PipeInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::PipeInfo& pipe() const {
+ ZX_ASSERT(ordinal() == Ordinal::kPipe);
+ return *static_cast<::llcpp::fuchsia::io2::PipeInfo*>(envelope_.data);
+ }
+
+ bool is_debuglog() const { return ordinal() == Ordinal::kDebuglog; }
+
+ static Representation WithDebuglog(::llcpp::fuchsia::io2::DebuglogInfo* val) {
+ Representation result;
+ result.set_debuglog(val);
+ return result;
+ }
+
+ // See [`NodeProtocolSet.DEBUGLOG`].
+ void set_debuglog(::llcpp::fuchsia::io2::DebuglogInfo* elem) {
+ ordinal_ = Ordinal::kDebuglog;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // See [`NodeProtocolSet.DEBUGLOG`].
+ ::llcpp::fuchsia::io2::DebuglogInfo& mutable_debuglog() {
+ ZX_ASSERT(ordinal() == Ordinal::kDebuglog);
+ return *static_cast<::llcpp::fuchsia::io2::DebuglogInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::DebuglogInfo& debuglog() const {
+ ZX_ASSERT(ordinal() == Ordinal::kDebuglog);
+ return *static_cast<::llcpp::fuchsia::io2::DebuglogInfo*>(envelope_.data);
+ }
+
+ bool is_device() const { return ordinal() == Ordinal::kDevice; }
+
+ static Representation WithDevice(::llcpp::fuchsia::io2::DeviceInfo* val) {
+ Representation result;
+ result.set_device(val);
+ return result;
+ }
+
+ void set_device(::llcpp::fuchsia::io2::DeviceInfo* elem) {
+ ordinal_ = Ordinal::kDevice;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::DeviceInfo& mutable_device() {
+ ZX_ASSERT(ordinal() == Ordinal::kDevice);
+ return *static_cast<::llcpp::fuchsia::io2::DeviceInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::DeviceInfo& device() const {
+ ZX_ASSERT(ordinal() == Ordinal::kDevice);
+ return *static_cast<::llcpp::fuchsia::io2::DeviceInfo*>(envelope_.data);
+ }
+
+ bool is_tty() const { return ordinal() == Ordinal::kTty; }
+
+ static Representation WithTty(::llcpp::fuchsia::io2::TtyInfo* val) {
+ Representation result;
+ result.set_tty(val);
+ return result;
+ }
+
+ void set_tty(::llcpp::fuchsia::io2::TtyInfo* elem) {
+ ordinal_ = Ordinal::kTty;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::io2::TtyInfo& mutable_tty() {
+ ZX_ASSERT(ordinal() == Ordinal::kTty);
+ return *static_cast<::llcpp::fuchsia::io2::TtyInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::io2::TtyInfo& tty() const {
+ ZX_ASSERT(ordinal() == Ordinal::kTty);
+ return *static_cast<::llcpp::fuchsia::io2::TtyInfo*>(envelope_.data);
+ }
+ void* unknownData() const {
+ ZX_ASSERT(which() == Tag::kUnknown);
+ return envelope_.data;
+ }
+ Tag which() const;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_RepresentationTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 64;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kConnector = 1, // 0x1
+ kDirectory = 2, // 0x2
+ kFile = 3, // 0x3
+ kMemory = 4, // 0x4
+ kPosixSocket = 5, // 0x5
+ kPipe = 6, // 0x6
+ kDebuglog = 7, // 0x7
+ kDevice = 8, // 0x8
+ kTty = 9, // 0x9
+ };
+
+ Ordinal ordinal() const {
+ switch (static_cast<fidl_xunion_tag_t>(ordinal_)) {
+ case 1:
+ case 1071926213:
+ return Ordinal::kConnector;
+ case 2:
+ case 1691175305:
+ return Ordinal::kDirectory;
+ case 3:
+ case 1881902475:
+ return Ordinal::kFile;
+ case 4:
+ case 1844477091:
+ return Ordinal::kMemory;
+ case 5:
+ case 220595477:
+ return Ordinal::kPosixSocket;
+ case 6:
+ case 439014286:
+ return Ordinal::kPipe;
+ case 7:
+ case 718851311:
+ return Ordinal::kDebuglog;
+ case 8:
+ case 1049166327:
+ return Ordinal::kDevice;
+ case 9:
+ case 1598881365:
+ return Ordinal::kTty;
+ }
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_ConnectionInfoTable;
+
+// Returns run-time information about a node that is specific to the
+// current connection.
+struct ConnectionInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // The active variant corresponds to one of the supported protocols
+ // of the node, and represents the result of the connection-time
+ // negotiation. Provides auxiliary handles if applicable.
+ const ::llcpp::fuchsia::io2::Representation& representation() const {
+ ZX_ASSERT(has_representation());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::Representation*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::Representation& representation() {
+ ZX_ASSERT(has_representation());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::Representation*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_representation() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Information about the rights possessed by the current connection.
+ // Note: `rights` limits the set of operations allowed on the connection,
+ // but does not guarantee their availability. For example, one may have
+ // the [`Rights.EXECUTE`] right on a file connection, but the file itself
+ // does not have the `EXECUTE` ability, and hence cannot be executed.
+ // See [`ConnectionOptions.rights`].
+ const ::llcpp::fuchsia::io2::Operations& rights() const {
+ ZX_ASSERT(has_rights());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::Operations& rights() {
+ ZX_ASSERT(has_rights());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_rights() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // The set of available operations on this channel. It is always the
+ // intersection between the rights possessed by this connection, and the
+ // abilities of the node. The value may be zero in the case of an empty
+ // intersection.
+ // See [`ConnectionOptions.rights`].
+ const ::llcpp::fuchsia::io2::Operations& available_operations() const {
+ ZX_ASSERT(has_available_operations());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::Operations& available_operations() {
+ ZX_ASSERT(has_available_operations());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_available_operations() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ ConnectionInfo() = default;
+ ~ConnectionInfo() = default;
+ ConnectionInfo(ConnectionInfo&& other) noexcept = default;
+ ConnectionInfo& operator=(ConnectionInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_ConnectionInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasPointer = true;
+
+ private:
+ ConnectionInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class ConnectionInfo::Builder {
+ public:
+ ConnectionInfo view() { return ConnectionInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // The active variant corresponds to one of the supported protocols
+ // of the node, and represents the result of the connection-time
+ // negotiation. Provides auxiliary handles if applicable.
+ Builder&& set_representation(::llcpp::fuchsia::io2::Representation* elem);
+
+ // Information about the rights possessed by the current connection.
+ // Note: `rights` limits the set of operations allowed on the connection,
+ // but does not guarantee their availability. For example, one may have
+ // the [`Rights.EXECUTE`] right on a file connection, but the file itself
+ // does not have the `EXECUTE` ability, and hence cannot be executed.
+ // See [`ConnectionOptions.rights`].
+ Builder&& set_rights(::llcpp::fuchsia::io2::Operations* elem);
+
+ // The set of available operations on this channel. It is always the
+ // intersection between the rights possessed by this connection, and the
+ // abilities of the node. The value may be zero in the case of an empty
+ // intersection.
+ // See [`ConnectionOptions.rights`].
+ Builder&& set_available_operations(::llcpp::fuchsia::io2::Operations* elem);
+
+ private:
+ Builder() = default;
+ friend Builder ConnectionInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 3> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_ConnectionOptionsTable;
+
+// Options for [`Directory.Open`] and [`Node.Reopen`].
+struct ConnectionOptions final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ // Flags which can affect the behavior when opening and reopening.
+ // If absent, assumes a default of zero.
+ const ::llcpp::fuchsia::io2::ConnectionFlags& flags() const {
+ ZX_ASSERT(has_flags());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::ConnectionFlags*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::ConnectionFlags& flags() {
+ ZX_ASSERT(has_flags());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::ConnectionFlags*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_flags() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // Specifies the set of representations accepted by the client, to support
+ // a form of protocol negotiation on the node being opened.
+ // Refer to the definition of [`NodeProtocolSet`] for more details.
+ // It cannot be zero.
+ //
+ // In addition, clients may assert the type of the object by setting
+ // the protocol corresponding to the expected type:
+ //
+ // * If the caller expected a directory but the node cannot be accessed
+ // as a directory, the error is `ZX_ERR_NOT_DIR`.
+ // * If the caller expected a file but the node cannot be accessed as a
+ // file, the error is `ZX_ERR_NOT_FILE`.
+ // * In other mismatched cases, the error is `ZX_ERR_WRONG_TYPE`.
+ //
+ // During [`Directory.Open`], if a new object is to be created, `protocols`
+ // determines the type of object to create; it must be present.
+ // If a valid object type cannot be unambiguously inferred e.g.
+ // both `DIRECTORY` and `FILE` were set, the request must fail.
+ //
+ // During [`Node.Reopen`], clients may specify a different but compatible
+ // `protocols` to do a "protocol upgrade".
+ //
+ // If more than one protocol is present in `protocols`, the resultant
+ // protocol may become any one of them. Clients should specify
+ // [`ConnectionFlags.GET_CONNECTION_INFO`] to receive a
+ // [`Node.OnConnectionInfo`] event, in order to ascertain the protocol.
+ //
+ // If absent, indicates that the caller accepts any type of node, and
+ // the resulting protocol is unspecified.
+ const ::llcpp::fuchsia::io2::NodeProtocolSet& protocols() const {
+ ZX_ASSERT(has_protocols());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::NodeProtocolSet*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::NodeProtocolSet& protocols() {
+ ZX_ASSERT(has_protocols());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::NodeProtocolSet*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_protocols() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // Requests the specified rights on the new connection. If absent, inherits
+ // the same rights as the source connection.
+ //
+ // ## Rights Hierarchy
+ //
+ // Respecting principles of least privileges, `rights` must meet the
+ // following restrictions:
+ //
+ // * A connection must have nonzero rights.
+ // * Rights must never increase in a derived connection:
+ // + During [`Directory.Open`], you may only request the same rights as
+ // what the directory connection already has, or a subset of those.
+ // + During [`Node.Reopen`], similarly, you may only request the same or
+ // a subset of rights possessed by the original connection.
+ // * Exceeding those rights causes `object_request` to be closed with a
+ // `ZX_ERR_ACCESS_DENIED` epitaph.
+ //
+ // The proper enforcement of the rights hierarchy is a powerful refinement
+ // over the existing access control facilities offered by directory
+ // sandboxing. The rights manipulation should be implemented mechanically
+ // without knowledge of any specific rights, and servers should propagate
+ // unknown bits members, to gracefully handle future rights extensions.
+ //
+ // ## Rights Inheritance
+ //
+ // Absent `rights` field means inheriting the same rights as the source.
+ //
+ // * During [`Node.Reopen`], the new connection would have the same rights
+ // as the connection where the `Reopen` call is made.
+ // * During [`Directory.Open`], the connection would have the same
+ // rights as the connection where the `Open` call is made.
+ //
+ // Note: `rights` limits the set of operations allowed on the new
+ // connection, but does not guarantee their availability. For convenience,
+ // clients may query the [`ConnectionInfo.available_operations`] field on a
+ // new connection, which is the intersection of the rights and abilities
+ // and indicates the guaranteed set of available operations.
+ //
+ // See [`fuchsia.io2/Rights`] and [`fuchsia.io2/Abilities`].
+ const ::llcpp::fuchsia::io2::Operations& rights() const {
+ ZX_ASSERT(has_rights());
+ return *reinterpret_cast<const ::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::llcpp::fuchsia::io2::Operations& rights() {
+ ZX_ASSERT(has_rights());
+ return *reinterpret_cast<::llcpp::fuchsia::io2::Operations*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_rights() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ ConnectionOptions() = default;
+ ~ConnectionOptions() = default;
+ ConnectionOptions(ConnectionOptions&& other) noexcept = default;
+ ConnectionOptions& operator=(ConnectionOptions&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_ConnectionOptionsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr bool HasPointer = true;
+
+ private:
+ ConnectionOptions(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class ConnectionOptions::Builder {
+ public:
+ ConnectionOptions view() { return ConnectionOptions(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ // Flags which can affect the behavior when opening and reopening.
+ // If absent, assumes a default of zero.
+ Builder&& set_flags(::llcpp::fuchsia::io2::ConnectionFlags* elem);
+
+ // Specifies the set of representations accepted by the client, to support
+ // a form of protocol negotiation on the node being opened.
+ // Refer to the definition of [`NodeProtocolSet`] for more details.
+ // It cannot be zero.
+ //
+ // In addition, clients may assert the type of the object by setting
+ // the protocol corresponding to the expected type:
+ //
+ // * If the caller expected a directory but the node cannot be accessed
+ // as a directory, the error is `ZX_ERR_NOT_DIR`.
+ // * If the caller expected a file but the node cannot be accessed as a
+ // file, the error is `ZX_ERR_NOT_FILE`.
+ // * In other mismatched cases, the error is `ZX_ERR_WRONG_TYPE`.
+ //
+ // During [`Directory.Open`], if a new object is to be created, `protocols`
+ // determines the type of object to create; it must be present.
+ // If a valid object type cannot be unambiguously inferred e.g.
+ // both `DIRECTORY` and `FILE` were set, the request must fail.
+ //
+ // During [`Node.Reopen`], clients may specify a different but compatible
+ // `protocols` to do a "protocol upgrade".
+ //
+ // If more than one protocol is present in `protocols`, the resultant
+ // protocol may become any one of them. Clients should specify
+ // [`ConnectionFlags.GET_CONNECTION_INFO`] to receive a
+ // [`Node.OnConnectionInfo`] event, in order to ascertain the protocol.
+ //
+ // If absent, indicates that the caller accepts any type of node, and
+ // the resulting protocol is unspecified.
+ Builder&& set_protocols(::llcpp::fuchsia::io2::NodeProtocolSet* elem);
+
+ // Requests the specified rights on the new connection. If absent, inherits
+ // the same rights as the source connection.
+ //
+ // ## Rights Hierarchy
+ //
+ // Respecting principles of least privileges, `rights` must meet the
+ // following restrictions:
+ //
+ // * A connection must have nonzero rights.
+ // * Rights must never increase in a derived connection:
+ // + During [`Directory.Open`], you may only request the same rights as
+ // what the directory connection already has, or a subset of those.
+ // + During [`Node.Reopen`], similarly, you may only request the same or
+ // a subset of rights possessed by the original connection.
+ // * Exceeding those rights causes `object_request` to be closed with a
+ // `ZX_ERR_ACCESS_DENIED` epitaph.
+ //
+ // The proper enforcement of the rights hierarchy is a powerful refinement
+ // over the existing access control facilities offered by directory
+ // sandboxing. The rights manipulation should be implemented mechanically
+ // without knowledge of any specific rights, and servers should propagate
+ // unknown bits members, to gracefully handle future rights extensions.
+ //
+ // ## Rights Inheritance
+ //
+ // Absent `rights` field means inheriting the same rights as the source.
+ //
+ // * During [`Node.Reopen`], the new connection would have the same rights
+ // as the connection where the `Reopen` call is made.
+ // * During [`Directory.Open`], the connection would have the same
+ // rights as the connection where the `Open` call is made.
+ //
+ // Note: `rights` limits the set of operations allowed on the new
+ // connection, but does not guarantee their availability. For convenience,
+ // clients may query the [`ConnectionInfo.available_operations`] field on a
+ // new connection, which is the intersection of the rights and abilities
+ // and indicates the guaranteed set of available operations.
+ //
+ // See [`fuchsia.io2/Rights`] and [`fuchsia.io2/Abilities`].
+ Builder&& set_rights(::llcpp::fuchsia::io2::Operations* elem);
+
+ private:
+ Builder() = default;
+ friend Builder ConnectionOptions::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 3> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_GetMemRange_ResponseTable;
+
+struct File_GetMemRange_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_GetMemRange_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::mem::Range buffer = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_Read_ResponseTable;
+
+struct File_Read_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_Read_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint8_t> data = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_ReadAt_ResponseTable;
+
+struct File_ReadAt_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_ReadAt_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint8_t> data = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Node_GetToken_ResponseTable;
+
+struct Node_GetToken_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Node_GetToken_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::handle token = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Node_UpdateAttributes_ResponseTable;
+
+struct Node_UpdateAttributes_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Node_UpdateAttributes_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Node_Sync_ResponseTable;
+
+struct Node_Sync_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Node_Sync_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+// The maximum I/O size that is allowed for read/write operations using
+// byte vectors.
+constexpr uint64_t MAX_TRANSFER_SIZE = 8192u;
+
+// The maximum length, in bytes, of a filesystem path.
+constexpr uint64_t MAX_PATH_LENGTH = 4095u;
+
+// The maximum length, in bytes, of a single filesystem component.
+constexpr uint64_t MAX_NAME_LENGTH = 255u;
+
+// The maximum number of directory entires or watcher events returned
+// in a batch by a hanging-get pattern.
+constexpr uint64_t MAX_DIRECTORY_BATCH_SIZE = 8192u;
+
+extern "C" const fidl_type_t v1_fuchsia_io2_IdleEventTable;
+
+struct IdleEvent {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_IdleEventTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Node_GetAttributes_ResponseTable;
+
+struct Node_GetAttributes_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Node_GetAttributes_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 192;
+ static constexpr bool HasPointer = true;
+
+ ::llcpp::fuchsia::io2::NodeAttributes attributes = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatcherGetNextRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatcherGetNextResponseTable;
+
+// DirectoryWatcher transmits messages from a filesystem server about
+// events happening in the filesystem. Clients can register new watchers
+// using the [`fuchsia.io2/Directory.Watch`] method, where they can
+// filter which events they want to receive notifications for.
+class DirectoryWatcher final {
+ DirectoryWatcher() = delete;
+ public:
+
+ struct GetNextResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryWatchedEvent> events;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryWatcherGetNextResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 3276800;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetNextRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetNext_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetNext_Impl(::zx::unowned_channel _client_end);
+ ~GetNext_Impl() = default;
+ GetNext_Impl(GetNext_Impl&& other) = default;
+ GetNext_Impl& operator=(GetNext_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 GetNext = GetNext_Impl<GetNextResponse>;
+ };
+
+ // 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 GetNext_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetNext_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetNext_Impl() = default;
+ GetNext_Impl(GetNext_Impl&& other) = default;
+ GetNext_Impl& operator=(GetNext_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 GetNext = GetNext_Impl<GetNextResponse>;
+ };
+
+ 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_; }
+
+ // A hanging get to obtain the next batch of events.
+ //
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // Clients should attempt to maintain one in-flight `GetNext` call as much
+ // as possible. If `GetNext` is not constantly polled, the filesystem
+ // server might hit an upper limit on the number of buffered events,
+ // resulting in dropping. Should this happen, the connection will be closed
+ // with a `ZX_ERR_IO_OVERRUN` epitaph.
+ //
+ // When the watched directory is deleted, this connection will be closed
+ // with a `ZX_ERR_UNAVAILABLE` epitaph.
+ // When the filesystem server is dying, this connection will be closed
+ // with a `ZX_ERR_PEER_CLOSED` epitaph.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetNext GetNext();
+
+ // A hanging get to obtain the next batch of events.
+ //
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // Clients should attempt to maintain one in-flight `GetNext` call as much
+ // as possible. If `GetNext` is not constantly polled, the filesystem
+ // server might hit an upper limit on the number of buffered events,
+ // resulting in dropping. Should this happen, the connection will be closed
+ // with a `ZX_ERR_IO_OVERRUN` epitaph.
+ //
+ // When the watched directory is deleted, this connection will be closed
+ // with a `ZX_ERR_UNAVAILABLE` epitaph.
+ // When the filesystem server is dying, this connection will be closed
+ // with a `ZX_ERR_PEER_CLOSED` epitaph.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetNext GetNext(::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:
+
+ // A hanging get to obtain the next batch of events.
+ //
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // Clients should attempt to maintain one in-flight `GetNext` call as much
+ // as possible. If `GetNext` is not constantly polled, the filesystem
+ // server might hit an upper limit on the number of buffered events,
+ // resulting in dropping. Should this happen, the connection will be closed
+ // with a `ZX_ERR_IO_OVERRUN` epitaph.
+ //
+ // When the watched directory is deleted, this connection will be closed
+ // with a `ZX_ERR_UNAVAILABLE` epitaph.
+ // When the filesystem server is dying, this connection will be closed
+ // with a `ZX_ERR_PEER_CLOSED` epitaph.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetNext GetNext(::zx::unowned_channel _client_end);
+
+ // A hanging get to obtain the next batch of events.
+ //
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // Clients should attempt to maintain one in-flight `GetNext` call as much
+ // as possible. If `GetNext` is not constantly polled, the filesystem
+ // server might hit an upper limit on the number of buffered events,
+ // resulting in dropping. Should this happen, the connection will be closed
+ // with a `ZX_ERR_IO_OVERRUN` epitaph.
+ //
+ // When the watched directory is deleted, this connection will be closed
+ // with a `ZX_ERR_UNAVAILABLE` epitaph.
+ // When the filesystem server is dying, this connection will be closed
+ // with a `ZX_ERR_PEER_CLOSED` epitaph.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetNext GetNext(::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:
+
+ // A hanging get to obtain the next batch of events.
+ //
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // Clients should attempt to maintain one in-flight `GetNext` call as much
+ // as possible. If `GetNext` is not constantly polled, the filesystem
+ // server might hit an upper limit on the number of buffered events,
+ // resulting in dropping. Should this happen, the connection will be closed
+ // with a `ZX_ERR_IO_OVERRUN` epitaph.
+ //
+ // When the watched directory is deleted, this connection will be closed
+ // with a `ZX_ERR_UNAVAILABLE` epitaph.
+ // When the filesystem server is dying, this connection will be closed
+ // with a `ZX_ERR_PEER_CLOSED` epitaph.
+ static ::fidl::DecodeResult<GetNextResponse> GetNext(::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 = DirectoryWatcher;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetNextCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryWatchedEvent> events);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryWatchedEvent> events);
+ void Reply(::fidl::DecodedMessage<GetNextResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetNextCompleter = ::fidl::Completer<GetNextCompleterBase>;
+
+ virtual void GetNext(GetNextCompleter::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 GetNextRequest(const ::fidl::DecodedMessage<DirectoryWatcher::GetNextRequest>& _msg);
+ static void GetNextResponse(const ::fidl::DecodedMessage<DirectoryWatcher::GetNextResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryIterator_GetNext_ResponseTable;
+
+struct DirectoryIterator_GetNext_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryIterator_GetNext_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 3080192;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryEntry> entries = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryIteratorGetNextRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryIteratorGetNextResponseTable;
+
+class DirectoryIterator final {
+ DirectoryIterator() = delete;
+ public:
+
+ struct GetNextResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryIteratorGetNextResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 3080208;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetNextRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetNext_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetNext_Impl(::zx::unowned_channel _client_end);
+ ~GetNext_Impl() = default;
+ GetNext_Impl(GetNext_Impl&& other) = default;
+ GetNext_Impl& operator=(GetNext_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 GetNext = GetNext_Impl<GetNextResponse>;
+ };
+
+ // 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 GetNext_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetNext_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetNext_Impl() = default;
+ GetNext_Impl(GetNext_Impl&& other) = default;
+ GetNext_Impl& operator=(GetNext_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 GetNext = GetNext_Impl<GetNextResponse>;
+ };
+
+ 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_; }
+
+ // Reads a collection of variably sized directory entries into a buffer.
+ //
+ // The number of entries in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to `Enumerate`.
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // When the end of iteration is reached, the returned `entries` vector
+ // will be empty.
+ //
+ // This method does not require any rights, as the rights are checked
+ // in the [`Directory.Enumerate`] call.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetNext GetNext();
+
+ // Reads a collection of variably sized directory entries into a buffer.
+ //
+ // The number of entries in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to `Enumerate`.
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // When the end of iteration is reached, the returned `entries` vector
+ // will be empty.
+ //
+ // This method does not require any rights, as the rights are checked
+ // in the [`Directory.Enumerate`] call.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetNext GetNext(::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:
+
+ // Reads a collection of variably sized directory entries into a buffer.
+ //
+ // The number of entries in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to `Enumerate`.
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // When the end of iteration is reached, the returned `entries` vector
+ // will be empty.
+ //
+ // This method does not require any rights, as the rights are checked
+ // in the [`Directory.Enumerate`] call.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetNext GetNext(::zx::unowned_channel _client_end);
+
+ // Reads a collection of variably sized directory entries into a buffer.
+ //
+ // The number of entries in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to `Enumerate`.
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // When the end of iteration is reached, the returned `entries` vector
+ // will be empty.
+ //
+ // This method does not require any rights, as the rights are checked
+ // in the [`Directory.Enumerate`] call.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetNext GetNext(::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:
+
+ // Reads a collection of variably sized directory entries into a buffer.
+ //
+ // The number of entries in a directory may be very large: akin to
+ // calling read multiple times on a file, directories have a seek
+ // offset which is updated on subsequent calls to `Enumerate`.
+ // The caller should always use a receiving buffer size as large as the
+ // maximum channel limit.
+ //
+ // When the end of iteration is reached, the returned `entries` vector
+ // will be empty.
+ //
+ // This method does not require any rights, as the rights are checked
+ // in the [`Directory.Enumerate`] call.
+ static ::fidl::DecodeResult<GetNextResponse> GetNext(::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 = DirectoryIterator;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetNextCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Result result);
+ void ReplySuccess(::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryEntry> entries);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fuchsia::io2::DirectoryEntry> entries);
+ void Reply(::fidl::DecodedMessage<GetNextResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetNextCompleter = ::fidl::Completer<GetNextCompleterBase>;
+
+ virtual void GetNext(GetNextCompleter::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 GetNextRequest(const ::fidl::DecodedMessage<DirectoryIterator::GetNextRequest>& _msg);
+ static void GetNextResponse(const ::fidl::DecodedMessage<DirectoryIterator::GetNextResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_Write_ResponseTable;
+
+struct File_Write_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_Write_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t actual_count = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_WriteAt_ResponseTable;
+
+struct File_WriteAt_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_WriteAt_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t actual_count = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_Seek_ResponseTable;
+
+struct File_Seek_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_Seek_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t offset_from_start = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_File_Resize_ResponseTable;
+
+struct File_Resize_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_File_Resize_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Directory_Unlink_ResponseTable;
+
+struct Directory_Unlink_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Directory_Unlink_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Directory_Rename_ResponseTable;
+
+struct Directory_Rename_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Directory_Rename_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_Directory_Link_ResponseTable;
+
+struct Directory_Link_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_Directory_Link_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeReopenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeOnConnectionInfoEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeGetAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeUpdateAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_NodeSyncResponseTable;
+
+// Node defines the minimal protocol for entities which can be accessed
+// in a filesystem.
+class Node final {
+ Node() = delete;
+ public:
+
+ struct ReopenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionOptions options;
+ ::zx::channel object_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeReopenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 72;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct DescribeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfoQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeDescribeRequestTable;
+ 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 = DescribeResponse;
+ };
+
+ struct OnConnectionInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeOnConnectionInfoEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetToken_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeGetTokenResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeGetAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 208;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributesQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeGetAttributesRequestTable;
+ 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 = GetAttributesResponse;
+ };
+
+ struct UpdateAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeUpdateAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UpdateAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeUpdateAttributesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 192;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = UpdateAttributesResponse;
+ };
+
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_Sync_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_NodeSyncResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+
+ struct EventHandlers {
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ fit::callback<zx_status_t(::llcpp::fuchsia::io2::ConnectionInfo info)> on_connection_info;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ };
+
+ // 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:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ };
+
+ 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_; }
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Reopen Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Reopen Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Describe Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetAttributes GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttributes GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UpdateAttributes UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UpdateAttributes UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ static ::fidl::internal::StatusAndError Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<GetAttributesResponse> GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<UpdateAttributesResponse> UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::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 = Node;
+ using _Base = ::fidl::CompleterBase;
+
+ using ReopenCompleter = ::fidl::Completer<>;
+
+ virtual void Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request, ReopenCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query, DescribeCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::zx::handle token);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class GetAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttributesCompleter = ::fidl::Completer<GetAttributesCompleterBase>;
+
+ virtual void GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query, GetAttributesCompleter::Sync _completer) = 0;
+
+ class UpdateAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UpdateAttributesCompleter = ::fidl::Completer<UpdateAttributesCompleterBase>;
+
+ virtual void UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes, UpdateAttributesCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::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);
+ }
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void ReopenRequest(const ::fidl::DecodedMessage<Node::ReopenRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Node::CloseRequest>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Node::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Node::DescribeResponse>& _msg);
+ static void OnConnectionInfoResponse(const ::fidl::DecodedMessage<Node::OnConnectionInfoResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<Node::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<Node::GetTokenResponse>& _msg);
+ static void GetAttributesRequest(const ::fidl::DecodedMessage<Node::GetAttributesRequest>& _msg);
+ static void GetAttributesResponse(const ::fidl::DecodedMessage<Node::GetAttributesResponse>& _msg);
+ static void UpdateAttributesRequest(const ::fidl::DecodedMessage<Node::UpdateAttributesRequest>& _msg);
+ static void UpdateAttributesResponse(const ::fidl::DecodedMessage<Node::UpdateAttributesResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Node::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Node::SyncResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeReopenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeOnConnectionInfoEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeGetAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeUpdateAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_PipeSyncResponseTable;
+
+// A node for streaming unstructured data.
+// No pipe-specific methods are provided by this protocol. The client should
+// access the pipe via the socket object returned from the `PipeInfo` member
+// in [`fuchsia.io2/Representation`].
+class Pipe final {
+ Pipe() = delete;
+ public:
+
+ struct ReopenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionOptions options;
+ ::zx::channel object_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeReopenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 72;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct DescribeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfoQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeDescribeRequestTable;
+ 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 = DescribeResponse;
+ };
+
+ struct OnConnectionInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeOnConnectionInfoEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetToken_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeGetTokenResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeGetAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 208;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributesQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeGetAttributesRequestTable;
+ 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 = GetAttributesResponse;
+ };
+
+ struct UpdateAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeUpdateAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UpdateAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeUpdateAttributesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 192;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = UpdateAttributesResponse;
+ };
+
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_Sync_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_PipeSyncResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+
+ struct EventHandlers {
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ fit::callback<zx_status_t(::llcpp::fuchsia::io2::ConnectionInfo info)> on_connection_info;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ };
+
+ // 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:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ };
+
+ 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_; }
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Reopen Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Reopen Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Describe Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetAttributes GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttributes GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UpdateAttributes UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UpdateAttributes UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ static ::fidl::internal::StatusAndError Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<GetAttributesResponse> GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<UpdateAttributesResponse> UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::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 = Pipe;
+ using _Base = ::fidl::CompleterBase;
+
+ using ReopenCompleter = ::fidl::Completer<>;
+
+ virtual void Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request, ReopenCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query, DescribeCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::zx::handle token);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class GetAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttributesCompleter = ::fidl::Completer<GetAttributesCompleterBase>;
+
+ virtual void GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query, GetAttributesCompleter::Sync _completer) = 0;
+
+ class UpdateAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UpdateAttributesCompleter = ::fidl::Completer<UpdateAttributesCompleterBase>;
+
+ virtual void UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes, UpdateAttributesCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::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);
+ }
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void ReopenRequest(const ::fidl::DecodedMessage<Pipe::ReopenRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Pipe::CloseRequest>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Pipe::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Pipe::DescribeResponse>& _msg);
+ static void OnConnectionInfoResponse(const ::fidl::DecodedMessage<Pipe::OnConnectionInfoResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<Pipe::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<Pipe::GetTokenResponse>& _msg);
+ static void GetAttributesRequest(const ::fidl::DecodedMessage<Pipe::GetAttributesRequest>& _msg);
+ static void GetAttributesResponse(const ::fidl::DecodedMessage<Pipe::GetAttributesResponse>& _msg);
+ static void UpdateAttributesRequest(const ::fidl::DecodedMessage<Pipe::UpdateAttributesRequest>& _msg);
+ static void UpdateAttributesResponse(const ::fidl::DecodedMessage<Pipe::UpdateAttributesResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Pipe::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Pipe::SyncResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryReopenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryOnConnectionInfoEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryGetAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemoryUpdateAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemorySyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_MemorySyncResponseTable;
+
+// A file-like node backed by a VMO.
+// No memory-specific methods are provided by this protocol.
+// The client should access it via the the [`MemoryInfo.buffer`] object in
+// [`fuchsia.io2/Representation`].
+class Memory final {
+ Memory() = delete;
+ public:
+
+ struct ReopenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionOptions options;
+ ::zx::channel object_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryReopenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 72;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct DescribeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfoQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryDescribeRequestTable;
+ 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 = DescribeResponse;
+ };
+
+ struct OnConnectionInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryOnConnectionInfoEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetToken_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryGetTokenResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryGetAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 208;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributesQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryGetAttributesRequestTable;
+ 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 = GetAttributesResponse;
+ };
+
+ struct UpdateAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryUpdateAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UpdateAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemoryUpdateAttributesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 192;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = UpdateAttributesResponse;
+ };
+
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_Sync_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_MemorySyncResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+
+ struct EventHandlers {
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ fit::callback<zx_status_t(::llcpp::fuchsia::io2::ConnectionInfo info)> on_connection_info;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ };
+
+ // 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:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ };
+
+ 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_; }
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Reopen Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Reopen Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Describe Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetAttributes GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttributes GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UpdateAttributes UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UpdateAttributes UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ static ::fidl::internal::StatusAndError Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<GetAttributesResponse> GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<UpdateAttributesResponse> UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::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 = Memory;
+ using _Base = ::fidl::CompleterBase;
+
+ using ReopenCompleter = ::fidl::Completer<>;
+
+ virtual void Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request, ReopenCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query, DescribeCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::zx::handle token);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class GetAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttributesCompleter = ::fidl::Completer<GetAttributesCompleterBase>;
+
+ virtual void GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query, GetAttributesCompleter::Sync _completer) = 0;
+
+ class UpdateAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UpdateAttributesCompleter = ::fidl::Completer<UpdateAttributesCompleterBase>;
+
+ virtual void UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes, UpdateAttributesCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::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);
+ }
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void ReopenRequest(const ::fidl::DecodedMessage<Memory::ReopenRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Memory::CloseRequest>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Memory::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Memory::DescribeResponse>& _msg);
+ static void OnConnectionInfoResponse(const ::fidl::DecodedMessage<Memory::OnConnectionInfoResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<Memory::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<Memory::GetTokenResponse>& _msg);
+ static void GetAttributesRequest(const ::fidl::DecodedMessage<Memory::GetAttributesRequest>& _msg);
+ static void GetAttributesResponse(const ::fidl::DecodedMessage<Memory::GetAttributesResponse>& _msg);
+ static void UpdateAttributesRequest(const ::fidl::DecodedMessage<Memory::UpdateAttributesRequest>& _msg);
+ static void UpdateAttributesResponse(const ::fidl::DecodedMessage<Memory::UpdateAttributesResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Memory::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Memory::SyncResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReopenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileOnConnectionInfoEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileUpdateAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileSeekRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileSeekResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReadRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReadResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileWriteRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileWriteResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReadAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileReadAtResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileWriteAtRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileWriteAtResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileResizeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileResizeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetMemRangeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_FileGetMemRangeResponseTable;
+
+// A [`fuchsia.io2/Node`] which contains a sequence of bytes of definite
+// length.
+class File final {
+ File() = delete;
+ public:
+
+ struct ReopenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionOptions options;
+ ::zx::channel object_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileReopenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 72;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct DescribeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfoQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileDescribeRequestTable;
+ 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 = DescribeResponse;
+ };
+
+ struct OnConnectionInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileOnConnectionInfoEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetToken_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileGetTokenResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileGetAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 208;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributesQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileGetAttributesRequestTable;
+ 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 = GetAttributesResponse;
+ };
+
+ struct UpdateAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileUpdateAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UpdateAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileUpdateAttributesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 192;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = UpdateAttributesResponse;
+ };
+
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_Sync_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileSyncResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SeekResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::File_Seek_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileSeekResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SeekRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::SeekOrigin origin;
+ int64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileSeekRequestTable;
+ 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 = SeekResponse;
+ };
+
+ struct ReadResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::File_Read_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileReadResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8208;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ReadRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileReadRequestTable;
+ 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 = ReadResponse;
+ };
+
+ struct WriteResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::File_Write_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileWriteResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct WriteRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileWriteRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = WriteResponse;
+ };
+
+ struct ReadAtResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::File_ReadAt_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileReadAtResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8208;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ReadAtRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t count;
+ uint64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileReadAtRequestTable;
+ 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 = ReadAtResponse;
+ };
+
+ struct WriteAtResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::File_WriteAt_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileWriteAtResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct WriteAtRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> data;
+ uint64_t offset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileWriteAtRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8192;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 8192;
+ 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 = WriteAtResponse;
+ };
+
+ struct ResizeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::File_Resize_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileResizeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ResizeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t length;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileResizeRequestTable;
+ 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 = ResizeResponse;
+ };
+
+ struct GetMemRangeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::File_GetMemRange_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileGetMemRangeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetMemRangeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::VmoFlags flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_FileGetMemRangeRequestTable;
+ 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 = GetMemRangeResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ fit::callback<zx_status_t(::llcpp::fuchsia::io2::ConnectionInfo info)> on_connection_info;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Seek_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Seek_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset);
+ ~Seek_Impl() = default;
+ Seek_Impl(Seek_Impl&& other) = default;
+ Seek_Impl& operator=(Seek_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 Read_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, uint64_t count);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 Write_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 ReadAt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadAt_Impl(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset);
+ ~ReadAt_Impl() = default;
+ ReadAt_Impl(ReadAt_Impl&& other) = default;
+ ReadAt_Impl& operator=(ReadAt_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 WriteAt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset);
+ ~WriteAt_Impl() = default;
+ WriteAt_Impl(WriteAt_Impl&& other) = default;
+ WriteAt_Impl& operator=(WriteAt_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 Resize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Resize_Impl(::zx::unowned_channel _client_end, uint64_t length);
+ ~Resize_Impl() = default;
+ Resize_Impl(Resize_Impl&& other) = default;
+ Resize_Impl& operator=(Resize_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 GetMemRange_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetMemRange_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::VmoFlags flags);
+ ~GetMemRange_Impl() = default;
+ GetMemRange_Impl(GetMemRange_Impl&& other) = default;
+ GetMemRange_Impl& operator=(GetMemRange_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using Seek = Seek_Impl<SeekResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using ReadAt = ReadAt_Impl<ReadAtResponse>;
+ using WriteAt = WriteAt_Impl<WriteAtResponse>;
+ using Resize = Resize_Impl<ResizeResponse>;
+ using GetMemRange = GetMemRange_Impl<GetMemRangeResponse>;
+ };
+
+ // 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:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Seek_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Seek_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset, ::fidl::BytePart _response_buffer);
+ ~Seek_Impl() = default;
+ Seek_Impl(Seek_Impl&& other) = default;
+ Seek_Impl& operator=(Seek_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 Read_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Read_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+ ~Read_Impl() = default;
+ Read_Impl(Read_Impl&& other) = default;
+ Read_Impl& operator=(Read_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 Write_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Write_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+ ~Write_Impl() = default;
+ Write_Impl(Write_Impl&& other) = default;
+ Write_Impl& operator=(Write_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 ReadAt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+ ~ReadAt_Impl() = default;
+ ReadAt_Impl(ReadAt_Impl&& other) = default;
+ ReadAt_Impl& operator=(ReadAt_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 WriteAt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteAt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+ ~WriteAt_Impl() = default;
+ WriteAt_Impl(WriteAt_Impl&& other) = default;
+ WriteAt_Impl& operator=(WriteAt_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 Resize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Resize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+ ~Resize_Impl() = default;
+ Resize_Impl(Resize_Impl&& other) = default;
+ Resize_Impl& operator=(Resize_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 GetMemRange_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetMemRange_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::VmoFlags flags, ::fidl::BytePart _response_buffer);
+ ~GetMemRange_Impl() = default;
+ GetMemRange_Impl(GetMemRange_Impl&& other) = default;
+ GetMemRange_Impl& operator=(GetMemRange_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using Seek = Seek_Impl<SeekResponse>;
+ using Read = Read_Impl<ReadResponse>;
+ using Write = Write_Impl<WriteResponse>;
+ using ReadAt = ReadAt_Impl<ReadAtResponse>;
+ using WriteAt = WriteAt_Impl<WriteAtResponse>;
+ using Resize = Resize_Impl<ResizeResponse>;
+ using GetMemRange = GetMemRange_Impl<GetMemRangeResponse>;
+ };
+
+ 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_; }
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Reopen Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Reopen Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Describe Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetAttributes GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttributes GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UpdateAttributes UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UpdateAttributes UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Moves the offset at which the next invocation of [`Read`] or [`Write`]
+ // will occur. The seek offset is specific to each file connection.
+ //
+ // + request `origin` the reference point where `offset` will be based on.
+ // + request `offset` the number of bytes to seek.
+ // - response `offset_from_start` the adjusted seek offset, from the start
+ // of the file.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Seek Seek(::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset);
+
+ // Moves the offset at which the next invocation of [`Read`] or [`Write`]
+ // will occur. The seek offset is specific to each file connection.
+ //
+ // + request `origin` the reference point where `offset` will be based on.
+ // + request `offset` the number of bytes to seek.
+ // - response `offset_from_start` the adjusted seek offset, from the start
+ // of the file.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Seek Seek(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Reads up to 'count' bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that the seek offset
+ // has reached the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that the
+ // seek offset is already at or beyond the end of file, and no data could
+ // be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually read anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Read Read(uint64_t count);
+
+ // Reads up to 'count' bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that the seek offset
+ // has reached the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that the
+ // seek offset is already at or beyond the end of file, and no data could
+ // be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually read anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Read Read(::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ // If the file is in append mode, the seek offset is first set to the end
+ // of the file, followed by the write, in one atomic step.
+ //
+ // The file size may grow if the seek offset plus `data.length` is beyond
+ // the current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file. The seek offset
+ // is still updated if in append mode.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Write Write(::fidl::VectorView<uint8_t> data);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ // If the file is in append mode, the seek offset is first set to the end
+ // of the file, followed by the write, in one atomic step.
+ //
+ // The file size may grow if the seek offset plus `data.length` is beyond
+ // the current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file. The seek offset
+ // is still updated if in append mode.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Write Write(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Reads up to 'count' bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that `ReadAt` has hit
+ // the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that `offset`
+ // is at or past the end of file, and no data can be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually reading anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::ReadAt ReadAt(uint64_t count, uint64_t offset);
+
+ // Reads up to 'count' bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that `ReadAt` has hit
+ // the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that `offset`
+ // is at or past the end of file, and no data can be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually reading anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadAt ReadAt(::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Writes data at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // The file size may grow if `offset` plus `data.length` is past the
+ // current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // + request `offset` the offset from start of the file to begin writing.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::WriteAt WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset);
+
+ // Writes data at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // The file size may grow if `offset` plus `data.length` is past the
+ // current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // + request `offset` the offset from start of the file to begin writing.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteAt WriteAt(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Shrinks or grows the file size to 'length' bytes.
+ //
+ // If file size is reduced by this operation, the extra trailing data'
+ // is discarded.
+ // If file size is increased by this operation, the extended area appears
+ // as if it was zeroed.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Resize Resize(uint64_t length);
+
+ // Shrinks or grows the file size to 'length' bytes.
+ //
+ // If file size is reduced by this operation, the extra trailing data'
+ // is discarded.
+ // If file size is increased by this operation, the extended area appears
+ // as if it was zeroed.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Resize Resize(::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+
+ // Acquires a [`fuchsia.mem/Range`] representing this file, if
+ // there is one, with the requested access rights.
+ //
+ // + request `flags` a [`VmoFlags`] indicating the desired mode of access.
+ // - response `buffer` the requested [`fuchsia.mem/Range`].
+ // * error a [`zx.status`] value indicating the failure.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
+ // * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
+ // * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
+ // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetMemRange GetMemRange(::llcpp::fuchsia::io2::VmoFlags flags);
+
+ // Acquires a [`fuchsia.mem/Range`] representing this file, if
+ // there is one, with the requested access rights.
+ //
+ // + request `flags` a [`VmoFlags`] indicating the desired mode of access.
+ // - response `buffer` the requested [`fuchsia.mem/Range`].
+ // * error a [`zx.status`] value indicating the failure.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
+ // * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
+ // * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetMemRange GetMemRange(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::VmoFlags flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Moves the offset at which the next invocation of [`Read`] or [`Write`]
+ // will occur. The seek offset is specific to each file connection.
+ //
+ // + request `origin` the reference point where `offset` will be based on.
+ // + request `offset` the number of bytes to seek.
+ // - response `offset_from_start` the adjusted seek offset, from the start
+ // of the file.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Seek Seek(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset);
+
+ // Moves the offset at which the next invocation of [`Read`] or [`Write`]
+ // will occur. The seek offset is specific to each file connection.
+ //
+ // + request `origin` the reference point where `offset` will be based on.
+ // + request `offset` the number of bytes to seek.
+ // - response `offset_from_start` the adjusted seek offset, from the start
+ // of the file.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Seek Seek(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Reads up to 'count' bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that the seek offset
+ // has reached the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that the
+ // seek offset is already at or beyond the end of file, and no data could
+ // be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually read anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Read Read(::zx::unowned_channel _client_end, uint64_t count);
+
+ // Reads up to 'count' bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that the seek offset
+ // has reached the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that the
+ // seek offset is already at or beyond the end of file, and no data could
+ // be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually read anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Read Read(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, ::fidl::BytePart _response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ // If the file is in append mode, the seek offset is first set to the end
+ // of the file, followed by the write, in one atomic step.
+ //
+ // The file size may grow if the seek offset plus `data.length` is beyond
+ // the current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file. The seek offset
+ // is still updated if in append mode.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ // If the file is in append mode, the seek offset is first set to the end
+ // of the file, followed by the write, in one atomic step.
+ //
+ // The file size may grow if the seek offset plus `data.length` is beyond
+ // the current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file. The seek offset
+ // is still updated if in append mode.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Write Write(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, ::fidl::BytePart _response_buffer);
+
+ // Reads up to 'count' bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that `ReadAt` has hit
+ // the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that `offset`
+ // is at or past the end of file, and no data can be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually reading anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::ReadAt ReadAt(::zx::unowned_channel _client_end, uint64_t count, uint64_t offset);
+
+ // Reads up to 'count' bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that `ReadAt` has hit
+ // the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that `offset`
+ // is at or past the end of file, and no data can be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually reading anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadAt ReadAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t count, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Writes data at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // The file size may grow if `offset` plus `data.length` is past the
+ // current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // + request `offset` the offset from start of the file to begin writing.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::WriteAt WriteAt(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> data, uint64_t offset);
+
+ // Writes data at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // The file size may grow if `offset` plus `data.length` is past the
+ // current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // + request `offset` the offset from start of the file to begin writing.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteAt WriteAt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> data, uint64_t offset, ::fidl::BytePart _response_buffer);
+
+ // Shrinks or grows the file size to 'length' bytes.
+ //
+ // If file size is reduced by this operation, the extra trailing data'
+ // is discarded.
+ // If file size is increased by this operation, the extended area appears
+ // as if it was zeroed.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Resize Resize(::zx::unowned_channel _client_end, uint64_t length);
+
+ // Shrinks or grows the file size to 'length' bytes.
+ //
+ // If file size is reduced by this operation, the extra trailing data'
+ // is discarded.
+ // If file size is increased by this operation, the extended area appears
+ // as if it was zeroed.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Resize Resize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t length, ::fidl::BytePart _response_buffer);
+
+ // Acquires a [`fuchsia.mem/Range`] representing this file, if
+ // there is one, with the requested access rights.
+ //
+ // + request `flags` a [`VmoFlags`] indicating the desired mode of access.
+ // - response `buffer` the requested [`fuchsia.mem/Range`].
+ // * error a [`zx.status`] value indicating the failure.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
+ // * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
+ // * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
+ // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetMemRange GetMemRange(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::VmoFlags flags);
+
+ // Acquires a [`fuchsia.mem/Range`] representing this file, if
+ // there is one, with the requested access rights.
+ //
+ // + request `flags` a [`VmoFlags`] indicating the desired mode of access.
+ // - response `buffer` the requested [`fuchsia.mem/Range`].
+ // * error a [`zx.status`] value indicating the failure.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
+ // * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
+ // * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetMemRange GetMemRange(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::VmoFlags flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ static ::fidl::internal::StatusAndError Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<GetAttributesResponse> GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<UpdateAttributesResponse> UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Moves the offset at which the next invocation of [`Read`] or [`Write`]
+ // will occur. The seek offset is specific to each file connection.
+ //
+ // + request `origin` the reference point where `offset` will be based on.
+ // + request `offset` the number of bytes to seek.
+ // - response `offset_from_start` the adjusted seek offset, from the start
+ // of the file.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SeekResponse> Seek(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SeekRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads up to 'count' bytes at the seek offset.
+ // The seek offset is moved forward by the number of bytes read.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that the seek offset
+ // has reached the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that the
+ // seek offset is already at or beyond the end of file, and no data could
+ // be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually read anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ static ::fidl::DecodeResult<ReadResponse> Read(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes data at the seek offset.
+ // The seek offset is moved forward by the number of bytes written.
+ // If the file is in append mode, the seek offset is first set to the end
+ // of the file, followed by the write, in one atomic step.
+ //
+ // The file size may grow if the seek offset plus `data.length` is beyond
+ // the current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file. The seek offset
+ // is still updated if in append mode.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ static ::fidl::DecodeResult<WriteResponse> Write(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads up to 'count' bytes at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // ## Invariants
+ //
+ // * The returned `data.length` will never be greater than `count`.
+ // * If `data.length` is less than `count`, it means that `ReadAt` has hit
+ // the end of file as part of this operation.
+ // * If `data.length` is zero while `count` is not, it means that `offset`
+ // is at or past the end of file, and no data can be read.
+ // * If `count` is zero, the server should perform all the checks ensuring
+ // read access without actually reading anything, and return an empty
+ // `data` vector.
+ //
+ // This method requires the [`Rights.READ_BYTES`] right.
+ static ::fidl::DecodeResult<ReadAtResponse> ReadAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAtRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes data at the provided offset.
+ // Does not affect the seek offset.
+ //
+ // The file size may grow if `offset` plus `data.length` is past the
+ // current end of file.
+ //
+ // + request `data` the byte buffer to write to the file.
+ // + request `offset` the offset from start of the file to begin writing.
+ // - response `actual_count` the number of bytes written.
+ //
+ // ## Invariants
+ //
+ // * The returned `actual_count` will never be greater than `data.length`.
+ // * If the server is unable to write all the data due to e.g. not enough
+ // space, `actual_count` may be less than `data.length`.
+ // * If `data.length` is zero, the server should perform all the checks
+ // ensuring write access without mutating the file.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ static ::fidl::DecodeResult<WriteAtResponse> WriteAt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAtRequest> params, ::fidl::BytePart response_buffer);
+
+ // Shrinks or grows the file size to 'length' bytes.
+ //
+ // If file size is reduced by this operation, the extra trailing data'
+ // is discarded.
+ // If file size is increased by this operation, the extended area appears
+ // as if it was zeroed.
+ //
+ // This method requires the [`Rights.WRITE_BYTES`] right.
+ static ::fidl::DecodeResult<ResizeResponse> Resize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResizeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a [`fuchsia.mem/Range`] representing this file, if
+ // there is one, with the requested access rights.
+ //
+ // + request `flags` a [`VmoFlags`] indicating the desired mode of access.
+ // - response `buffer` the requested [`fuchsia.mem/Range`].
+ // * error a [`zx.status`] value indicating the failure.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.READ_BYTES`] if `flags` includes [`VmoFlags.READ`].
+ // * [`Rights.WRITE_BYTES`] if `flags` includes [`VmoFlags.WRITE`].
+ // * [`Rights.EXECUTE`] if `flags` includes [`VmoFlags.EXECUTE`].
+ static ::fidl::DecodeResult<GetMemRangeResponse> GetMemRange(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetMemRangeRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = File;
+ using _Base = ::fidl::CompleterBase;
+
+ using ReopenCompleter = ::fidl::Completer<>;
+
+ virtual void Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request, ReopenCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query, DescribeCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::zx::handle token);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class GetAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttributesCompleter = ::fidl::Completer<GetAttributesCompleterBase>;
+
+ virtual void GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query, GetAttributesCompleter::Sync _completer) = 0;
+
+ class UpdateAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UpdateAttributesCompleter = ::fidl::Completer<UpdateAttributesCompleterBase>;
+
+ virtual void UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes, UpdateAttributesCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class SeekCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::File_Seek_Result result);
+ void ReplySuccess(uint64_t offset_from_start);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_Seek_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint64_t offset_from_start);
+ void Reply(::fidl::DecodedMessage<SeekResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SeekCompleter = ::fidl::Completer<SeekCompleterBase>;
+
+ virtual void Seek(::llcpp::fuchsia::io2::SeekOrigin origin, int64_t offset, SeekCompleter::Sync _completer) = 0;
+
+ class ReadCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::File_Read_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> data);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_Read_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<ReadResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadCompleter = ::fidl::Completer<ReadCompleterBase>;
+
+ virtual void Read(uint64_t count, ReadCompleter::Sync _completer) = 0;
+
+ class WriteCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::File_Write_Result result);
+ void ReplySuccess(uint64_t actual_count);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_Write_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint64_t actual_count);
+ void Reply(::fidl::DecodedMessage<WriteResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteCompleter = ::fidl::Completer<WriteCompleterBase>;
+
+ virtual void Write(::fidl::VectorView<uint8_t> data, WriteCompleter::Sync _completer) = 0;
+
+ class ReadAtCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::File_ReadAt_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> data);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_ReadAt_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> data);
+ void Reply(::fidl::DecodedMessage<ReadAtResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadAtCompleter = ::fidl::Completer<ReadAtCompleterBase>;
+
+ virtual void ReadAt(uint64_t count, uint64_t offset, ReadAtCompleter::Sync _completer) = 0;
+
+ class WriteAtCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::File_WriteAt_Result result);
+ void ReplySuccess(uint64_t actual_count);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_WriteAt_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, uint64_t actual_count);
+ void Reply(::fidl::DecodedMessage<WriteAtResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteAtCompleter = ::fidl::Completer<WriteAtCompleterBase>;
+
+ virtual void WriteAt(::fidl::VectorView<uint8_t> data, uint64_t offset, WriteAtCompleter::Sync _completer) = 0;
+
+ class ResizeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::File_Resize_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_Resize_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ResizeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ResizeCompleter = ::fidl::Completer<ResizeCompleterBase>;
+
+ virtual void Resize(uint64_t length, ResizeCompleter::Sync _completer) = 0;
+
+ class GetMemRangeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::File_GetMemRange_Result result);
+ void ReplySuccess(::llcpp::fuchsia::mem::Range buffer);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::File_GetMemRange_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::mem::Range buffer);
+ void Reply(::fidl::DecodedMessage<GetMemRangeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetMemRangeCompleter = ::fidl::Completer<GetMemRangeCompleterBase>;
+
+ virtual void GetMemRange(::llcpp::fuchsia::io2::VmoFlags flags, GetMemRangeCompleter::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);
+ }
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void ReopenRequest(const ::fidl::DecodedMessage<File::ReopenRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<File::CloseRequest>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<File::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<File::DescribeResponse>& _msg);
+ static void OnConnectionInfoResponse(const ::fidl::DecodedMessage<File::OnConnectionInfoResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<File::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<File::GetTokenResponse>& _msg);
+ static void GetAttributesRequest(const ::fidl::DecodedMessage<File::GetAttributesRequest>& _msg);
+ static void GetAttributesResponse(const ::fidl::DecodedMessage<File::GetAttributesResponse>& _msg);
+ static void UpdateAttributesRequest(const ::fidl::DecodedMessage<File::UpdateAttributesRequest>& _msg);
+ static void UpdateAttributesResponse(const ::fidl::DecodedMessage<File::UpdateAttributesResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<File::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<File::SyncResponse>& _msg);
+ static void SeekRequest(const ::fidl::DecodedMessage<File::SeekRequest>& _msg);
+ static void SeekResponse(const ::fidl::DecodedMessage<File::SeekResponse>& _msg);
+ static void ReadRequest(const ::fidl::DecodedMessage<File::ReadRequest>& _msg);
+ static void ReadResponse(const ::fidl::DecodedMessage<File::ReadResponse>& _msg);
+ static void WriteRequest(const ::fidl::DecodedMessage<File::WriteRequest>& _msg);
+ static void WriteResponse(const ::fidl::DecodedMessage<File::WriteResponse>& _msg);
+ static void ReadAtRequest(const ::fidl::DecodedMessage<File::ReadAtRequest>& _msg);
+ static void ReadAtResponse(const ::fidl::DecodedMessage<File::ReadAtResponse>& _msg);
+ static void WriteAtRequest(const ::fidl::DecodedMessage<File::WriteAtRequest>& _msg);
+ static void WriteAtResponse(const ::fidl::DecodedMessage<File::WriteAtResponse>& _msg);
+ static void ResizeRequest(const ::fidl::DecodedMessage<File::ResizeRequest>& _msg);
+ static void ResizeResponse(const ::fidl::DecodedMessage<File::ResizeResponse>& _msg);
+ static void GetMemRangeRequest(const ::fidl::DecodedMessage<File::GetMemRangeRequest>& _msg);
+ static void GetMemRangeResponse(const ::fidl::DecodedMessage<File::GetMemRangeResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryReopenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryOnConnectionInfoEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryGetAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryUpdateAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectorySyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectorySyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryOpenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryUnlinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryUnlinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryEnumerateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryEnumerateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryRenameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryRenameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryLinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryLinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DirectoryWatchResponseTable;
+
+// A [`fuchsia.io2/Node`] that is capable of containing other nodes.
+class Directory final {
+ Directory() = delete;
+ public:
+
+ struct ReopenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionOptions options;
+ ::zx::channel object_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryReopenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 72;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct DescribeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfoQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryDescribeRequestTable;
+ 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 = DescribeResponse;
+ };
+
+ struct OnConnectionInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryOnConnectionInfoEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetToken_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryGetTokenResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryGetAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 208;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributesQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryGetAttributesRequestTable;
+ 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 = GetAttributesResponse;
+ };
+
+ struct UpdateAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryUpdateAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UpdateAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryUpdateAttributesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 192;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = UpdateAttributesResponse;
+ };
+
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_Sync_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectorySyncResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OpenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView path;
+ ::llcpp::fuchsia::io2::OpenMode mode;
+ ::llcpp::fuchsia::io2::ConnectionOptions options;
+ ::zx::channel object_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryOpenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 64;
+ static constexpr uint32_t MaxOutOfLine = 4168;
+ static constexpr uint32_t AltPrimarySize = 64;
+ static constexpr uint32_t AltMaxOutOfLine = 4168;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ struct UnlinkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Directory_Unlink_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryUnlinkResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UnlinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView path;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryUnlinkRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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 = UnlinkResponse;
+ };
+
+ struct EnumerateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options;
+ ::zx::channel iterator;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryEnumerateRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 0;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ struct RenameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Directory_Rename_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryRenameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RenameRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView src;
+ ::zx::handle dst_parent_token;
+ ::fidl::StringView dst;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryRenameRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 512;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 512;
+ 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 = RenameResponse;
+ };
+
+ struct LinkResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Directory_Link_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryLinkResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct LinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView src;
+ ::zx::handle dst_parent_token;
+ ::fidl::StringView dst;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryLinkRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 56;
+ static constexpr uint32_t MaxOutOfLine = 512;
+ static constexpr uint32_t AltPrimarySize = 56;
+ static constexpr uint32_t AltMaxOutOfLine = 512;
+ 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 = LinkResponse;
+ };
+
+ struct WatchRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::DirectoryWatchMask mask;
+ ::llcpp::fuchsia::io2::DirectoryWatchOptions options;
+ ::zx::channel watcher;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DirectoryWatchRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ fit::callback<zx_status_t(::llcpp::fuchsia::io2::ConnectionInfo info)> on_connection_info;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Open_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Unlink_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::StringView path);
+ ~Unlink_Impl() = default;
+ Unlink_Impl(Unlink_Impl&& other) = default;
+ Unlink_Impl& operator=(Unlink_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Enumerate_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Enumerate_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator);
+ ~Enumerate_Impl() = default;
+ Enumerate_Impl(Enumerate_Impl&& other) = default;
+ Enumerate_Impl& operator=(Enumerate_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Rename_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Rename_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+ ~Rename_Impl() = default;
+ Rename_Impl(Rename_Impl&& other) = default;
+ Rename_Impl& operator=(Rename_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 Link_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Link_Impl(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+ ~Link_Impl() = default;
+ Link_Impl(Link_Impl&& other) = default;
+ Link_Impl& operator=(Link_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Watch_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Watch_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher);
+ ~Watch_Impl() = default;
+ Watch_Impl(Watch_Impl&& other) = default;
+ Watch_Impl& operator=(Watch_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using Open = Open_Impl;
+ using Unlink = Unlink_Impl<UnlinkResponse>;
+ using Enumerate = Enumerate_Impl;
+ using Rename = Rename_Impl<RenameResponse>;
+ using Link = Link_Impl<LinkResponse>;
+ using Watch = Watch_Impl;
+ };
+
+ // 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:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Open_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Open_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Open_Impl() = default;
+ Open_Impl(Open_Impl&& other) = default;
+ Open_Impl& operator=(Open_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Unlink_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Unlink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+ ~Unlink_Impl() = default;
+ Unlink_Impl(Unlink_Impl&& other) = default;
+ Unlink_Impl& operator=(Unlink_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Enumerate_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Enumerate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator);
+ ~Enumerate_Impl() = default;
+ Enumerate_Impl(Enumerate_Impl&& other) = default;
+ Enumerate_Impl& operator=(Enumerate_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Rename_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Rename_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+ ~Rename_Impl() = default;
+ Rename_Impl(Rename_Impl&& other) = default;
+ Rename_Impl& operator=(Rename_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 Link_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Link_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+ ~Link_Impl() = default;
+ Link_Impl(Link_Impl&& other) = default;
+ Link_Impl& operator=(Link_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Watch_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Watch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher);
+ ~Watch_Impl() = default;
+ Watch_Impl(Watch_Impl&& other) = default;
+ Watch_Impl& operator=(Watch_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using Open = Open_Impl;
+ using Unlink = Unlink_Impl<UnlinkResponse>;
+ using Enumerate = Enumerate_Impl;
+ using Rename = Rename_Impl<RenameResponse>;
+ using Link = Link_Impl<LinkResponse>;
+ using Watch = Watch_Impl;
+ };
+
+ 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_; }
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Reopen Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Reopen Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Describe Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetAttributes GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttributes GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UpdateAttributes UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UpdateAttributes UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Opens or creates a new node relative to this directory node.
+ //
+ // + `path` identifies the node to open.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ // See [`fuchsia.io2/Path`] for what constitutes a valid path.
+ // To open another connection to the current directory, use
+ // [`fuchsia.io2/Node.Reopen`] instead.
+ // + `mode` controls whether to open existing/create new etc.
+ // + `options` additional options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // This method requires the following rights on the current connection:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.TRAVERSE`]
+ //
+ // Errors are presented as an epitaph on the `object_request` channel.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
+ // what is allowed.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // Request is heap-allocated.
+ ResultOf::Open Open(::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Opens or creates a new node relative to this directory node.
+ //
+ // + `path` identifies the node to open.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ // See [`fuchsia.io2/Path`] for what constitutes a valid path.
+ // To open another connection to the current directory, use
+ // [`fuchsia.io2/Node.Reopen`] instead.
+ // + `mode` controls whether to open existing/create new etc.
+ // + `options` additional options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // This method requires the following rights on the current connection:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.TRAVERSE`]
+ //
+ // Errors are presented as an epitaph on the `object_request` channel.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
+ // what is allowed.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Open Open(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Removes a child node from the this directory's list of entries.
+ //
+ // Note: this does not guarantee that the underlying object is destroyed.
+ // Although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are closed.
+ //
+ // + `path` identifies the node to be detached.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
+ // [`Rights.WRITE_BYTES`].
+ // * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
+ // support writing.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // * error `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // * error `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point,
+ // containing a remote channel.
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Unlink Unlink(::fidl::StringView path);
+
+ // Removes a child node from the this directory's list of entries.
+ //
+ // Note: this does not guarantee that the underlying object is destroyed.
+ // Although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are closed.
+ //
+ // + `path` identifies the node to be detached.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
+ // [`Rights.WRITE_BYTES`].
+ // * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
+ // support writing.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // * error `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // * error `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point,
+ // containing a remote channel.
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Unlink Unlink(::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+
+ // Initiates a directory listing operation over the input channel,
+ // starting at seek offset 0.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Enumerate Enumerate(::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator);
+
+ // Initiates a directory listing operation over the input channel,
+ // starting at seek offset 0.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Enumerate Enumerate(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator);
+
+ // Renames a node named `src` to the name `dst`, in a directory represented
+ // by `dst_parent_token`.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Rename Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Renames a node named `src` to the name `dst`, in a directory represented
+ // by `dst_parent_token`.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Rename Rename(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Creates a link to a node named `src` by the name `dst`,
+ // in a directory represented by `dst_parent_token`.
+ //
+ // Directories cannot be linked, to prevent reference cycles.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // * error `ZX_ERR_INVALID_ARGS` if `src` is a directory.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Link Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Creates a link to a node named `src` by the name `dst`,
+ // in a directory represented by `dst_parent_token`.
+ //
+ // Directories cannot be linked, to prevent reference cycles.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // * error `ZX_ERR_INVALID_ARGS` if `src` is a directory.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Link Link(::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, monitoring events for children being added or
+ // removed on the server end of the `watcher` channel.
+ //
+ // Mask specifies a bit mask of events to observe.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `watcher` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Watch Watch(::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher);
+
+ // Watches a directory, monitoring events for children being added or
+ // removed on the server end of the `watcher` channel.
+ //
+ // Mask specifies a bit mask of events to observe.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `watcher` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Watch Watch(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Opens or creates a new node relative to this directory node.
+ //
+ // + `path` identifies the node to open.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ // See [`fuchsia.io2/Path`] for what constitutes a valid path.
+ // To open another connection to the current directory, use
+ // [`fuchsia.io2/Node.Reopen`] instead.
+ // + `mode` controls whether to open existing/create new etc.
+ // + `options` additional options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // This method requires the following rights on the current connection:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.TRAVERSE`]
+ //
+ // Errors are presented as an epitaph on the `object_request` channel.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
+ // what is allowed.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // Request is heap-allocated.
+ static ResultOf::Open Open(::zx::unowned_channel _client_end, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Opens or creates a new node relative to this directory node.
+ //
+ // + `path` identifies the node to open.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ // See [`fuchsia.io2/Path`] for what constitutes a valid path.
+ // To open another connection to the current directory, use
+ // [`fuchsia.io2/Node.Reopen`] instead.
+ // + `mode` controls whether to open existing/create new etc.
+ // + `options` additional options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // This method requires the following rights on the current connection:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.TRAVERSE`]
+ //
+ // Errors are presented as an epitaph on the `object_request` channel.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
+ // what is allowed.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Open Open(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Removes a child node from the this directory's list of entries.
+ //
+ // Note: this does not guarantee that the underlying object is destroyed.
+ // Although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are closed.
+ //
+ // + `path` identifies the node to be detached.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
+ // [`Rights.WRITE_BYTES`].
+ // * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
+ // support writing.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // * error `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // * error `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point,
+ // containing a remote channel.
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::StringView path);
+
+ // Removes a child node from the this directory's list of entries.
+ //
+ // Note: this does not guarantee that the underlying object is destroyed.
+ // Although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are closed.
+ //
+ // + `path` identifies the node to be detached.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
+ // [`Rights.WRITE_BYTES`].
+ // * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
+ // support writing.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // * error `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // * error `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point,
+ // containing a remote channel.
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Unlink Unlink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView path, ::fidl::BytePart _response_buffer);
+
+ // Initiates a directory listing operation over the input channel,
+ // starting at seek offset 0.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Enumerate Enumerate(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator);
+
+ // Initiates a directory listing operation over the input channel,
+ // starting at seek offset 0.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Enumerate Enumerate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator);
+
+ // Renames a node named `src` to the name `dst`, in a directory represented
+ // by `dst_parent_token`.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Renames a node named `src` to the name `dst`, in a directory represented
+ // by `dst_parent_token`.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Rename Rename(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Creates a link to a node named `src` by the name `dst`,
+ // in a directory represented by `dst_parent_token`.
+ //
+ // Directories cannot be linked, to prevent reference cycles.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // * error `ZX_ERR_INVALID_ARGS` if `src` is a directory.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst);
+
+ // Creates a link to a node named `src` by the name `dst`,
+ // in a directory represented by `dst_parent_token`.
+ //
+ // Directories cannot be linked, to prevent reference cycles.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // * error `ZX_ERR_INVALID_ARGS` if `src` is a directory.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Link Link(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, ::fidl::BytePart _response_buffer);
+
+ // Watches a directory, monitoring events for children being added or
+ // removed on the server end of the `watcher` channel.
+ //
+ // Mask specifies a bit mask of events to observe.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `watcher` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Watch Watch(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher);
+
+ // Watches a directory, monitoring events for children being added or
+ // removed on the server end of the `watcher` channel.
+ //
+ // Mask specifies a bit mask of events to observe.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `watcher` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Watch Watch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ static ::fidl::internal::StatusAndError Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<GetAttributesResponse> GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<UpdateAttributesResponse> UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Opens or creates a new node relative to this directory node.
+ //
+ // + `path` identifies the node to open.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ // See [`fuchsia.io2/Path`] for what constitutes a valid path.
+ // To open another connection to the current directory, use
+ // [`fuchsia.io2/Node.Reopen`] instead.
+ // + `mode` controls whether to open existing/create new etc.
+ // + `options` additional options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // This method requires the following rights on the current connection:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.TRAVERSE`]
+ //
+ // Errors are presented as an epitaph on the `object_request` channel.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the requested rights exceeds
+ // what is allowed.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ static ::fidl::internal::StatusAndError Open(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenRequest> params);
+
+ // Removes a child node from the this directory's list of entries.
+ //
+ // Note: this does not guarantee that the underlying object is destroyed.
+ // Although the link will be removed from the containing directory,
+ // objects with multiple references (such as files which are still open)
+ // will not actually be destroyed until all references are closed.
+ //
+ // + `path` identifies the node to be detached.
+ // If `path` contains multiple segments, then the directory is traversed,
+ // one segment at a time, relative to the directory represented by this
+ // connection.
+ //
+ // * error `ZX_ERR_ACCESS_DENIED` if the connection does not have
+ // [`Rights.WRITE_BYTES`].
+ // * error `ZX_ERR_NOT_SUPPORTED` if the underlying filesystem does not
+ // support writing.
+ // * error `ZX_ERR_BAD_PATH` if `path` is invalid.
+ // * error `ZX_ERR_NOT_EMPTY` if `path` refers to a non-empty directory.
+ // * error `ZX_ERR_UNAVAILABLE` if `path` refers to a mount point,
+ // containing a remote channel.
+ //
+ // Other errors may be returned for filesystem-specific reasons.
+ //
+ // This method requires the following rights:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ static ::fidl::DecodeResult<UnlinkResponse> Unlink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UnlinkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Initiates a directory listing operation over the input channel,
+ // starting at seek offset 0.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `iterator` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ static ::fidl::internal::StatusAndError Enumerate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EnumerateRequest> params);
+
+ // Renames a node named `src` to the name `dst`, in a directory represented
+ // by `dst_parent_token`.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ static ::fidl::DecodeResult<RenameResponse> Rename(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RenameRequest> params, ::fidl::BytePart response_buffer);
+
+ // Creates a link to a node named `src` by the name `dst`,
+ // in a directory represented by `dst_parent_token`.
+ //
+ // Directories cannot be linked, to prevent reference cycles.
+ //
+ // `src` and `dst` must be valid node names.
+ // See [`fuchsia.io2/Name`] for what constitutes a valid name.
+ //
+ // This method requires the following rights on both the current
+ // connection, and the connection identified by `dst_parent_token`:
+ //
+ // * [`Rights.ENUMERATE`]
+ // * [`Rights.MODIFY_DIRECTORY`]
+ //
+ // * error `ZX_ERR_INVALID_ARGS` if `src` or `dst` is invalid.
+ // * error `ZX_ERR_INVALID_ARGS` if `src` is a directory.
+ static ::fidl::DecodeResult<LinkResponse> Link(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LinkRequest> params, ::fidl::BytePart response_buffer);
+
+ // Watches a directory, monitoring events for children being added or
+ // removed on the server end of the `watcher` channel.
+ //
+ // Mask specifies a bit mask of events to observe.
+ //
+ // This method requires the [`Rights.ENUMERATE`] right. If this right is
+ // absent, `watcher` will be closed with a `ZX_ERR_ACCESS_DENIED` epitaph.
+ static ::fidl::internal::StatusAndError Watch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WatchRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Directory;
+ using _Base = ::fidl::CompleterBase;
+
+ using ReopenCompleter = ::fidl::Completer<>;
+
+ virtual void Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request, ReopenCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query, DescribeCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::zx::handle token);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class GetAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttributesCompleter = ::fidl::Completer<GetAttributesCompleterBase>;
+
+ virtual void GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query, GetAttributesCompleter::Sync _completer) = 0;
+
+ class UpdateAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UpdateAttributesCompleter = ::fidl::Completer<UpdateAttributesCompleterBase>;
+
+ virtual void UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes, UpdateAttributesCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ using OpenCompleter = ::fidl::Completer<>;
+
+ virtual void Open(::fidl::StringView path, ::llcpp::fuchsia::io2::OpenMode mode, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request, OpenCompleter::Sync _completer) = 0;
+
+ class UnlinkCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Directory_Unlink_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Directory_Unlink_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UnlinkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UnlinkCompleter = ::fidl::Completer<UnlinkCompleterBase>;
+
+ virtual void Unlink(::fidl::StringView path, UnlinkCompleter::Sync _completer) = 0;
+
+ using EnumerateCompleter = ::fidl::Completer<>;
+
+ virtual void Enumerate(::llcpp::fuchsia::io2::DirectoryEnumerateOptions options, ::zx::channel iterator, EnumerateCompleter::Sync _completer) = 0;
+
+ class RenameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Directory_Rename_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Directory_Rename_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<RenameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RenameCompleter = ::fidl::Completer<RenameCompleterBase>;
+
+ virtual void Rename(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, RenameCompleter::Sync _completer) = 0;
+
+ class LinkCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Directory_Link_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Directory_Link_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<LinkResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LinkCompleter = ::fidl::Completer<LinkCompleterBase>;
+
+ virtual void Link(::fidl::StringView src, ::zx::handle dst_parent_token, ::fidl::StringView dst, LinkCompleter::Sync _completer) = 0;
+
+ using WatchCompleter = ::fidl::Completer<>;
+
+ virtual void Watch(::llcpp::fuchsia::io2::DirectoryWatchMask mask, ::llcpp::fuchsia::io2::DirectoryWatchOptions options, ::zx::channel watcher, WatchCompleter::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);
+ }
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void ReopenRequest(const ::fidl::DecodedMessage<Directory::ReopenRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Directory::CloseRequest>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Directory::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Directory::DescribeResponse>& _msg);
+ static void OnConnectionInfoResponse(const ::fidl::DecodedMessage<Directory::OnConnectionInfoResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<Directory::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<Directory::GetTokenResponse>& _msg);
+ static void GetAttributesRequest(const ::fidl::DecodedMessage<Directory::GetAttributesRequest>& _msg);
+ static void GetAttributesResponse(const ::fidl::DecodedMessage<Directory::GetAttributesResponse>& _msg);
+ static void UpdateAttributesRequest(const ::fidl::DecodedMessage<Directory::UpdateAttributesRequest>& _msg);
+ static void UpdateAttributesResponse(const ::fidl::DecodedMessage<Directory::UpdateAttributesResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Directory::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Directory::SyncResponse>& _msg);
+ static void OpenRequest(const ::fidl::DecodedMessage<Directory::OpenRequest>& _msg);
+ static void UnlinkRequest(const ::fidl::DecodedMessage<Directory::UnlinkRequest>& _msg);
+ static void UnlinkResponse(const ::fidl::DecodedMessage<Directory::UnlinkResponse>& _msg);
+ static void EnumerateRequest(const ::fidl::DecodedMessage<Directory::EnumerateRequest>& _msg);
+ static void RenameRequest(const ::fidl::DecodedMessage<Directory::RenameRequest>& _msg);
+ static void RenameResponse(const ::fidl::DecodedMessage<Directory::RenameResponse>& _msg);
+ static void LinkRequest(const ::fidl::DecodedMessage<Directory::LinkRequest>& _msg);
+ static void LinkResponse(const ::fidl::DecodedMessage<Directory::LinkResponse>& _msg);
+ static void WatchRequest(const ::fidl::DecodedMessage<Directory::WatchRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogReopenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogReopenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogOnConnectionInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogOnConnectionInfoEventTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogGetTokenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogGetTokenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogGetAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogGetAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogUpdateAttributesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogUpdateAttributesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_io2_DebuglogSyncResponseTable;
+
+// A node for interacting with the kernel debug log.
+// It may be manipulated via the debuglog object returned from
+// the `DebuglogInfo` member in [`fuchsia.io2/Representation`].
+class Debuglog final {
+ Debuglog() = delete;
+ public:
+
+ struct ReopenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionOptions options;
+ ::zx::channel object_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogReopenRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 72;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 72;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ };
+
+ using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct DescribeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfoQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogDescribeRequestTable;
+ 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 = DescribeResponse;
+ };
+
+ struct OnConnectionInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::ConnectionInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogOnConnectionInfoEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 152;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetTokenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetToken_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogGetTokenResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetTokenRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_GetAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogGetAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 208;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributesQuery query;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogGetAttributesRequestTable;
+ 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 = GetAttributesResponse;
+ };
+
+ struct UpdateAttributesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogUpdateAttributesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct UpdateAttributesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogUpdateAttributesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 192;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 192;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = UpdateAttributesResponse;
+ };
+
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io2::Node_Sync_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_io2_DebuglogSyncResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+
+ struct EventHandlers {
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ fit::callback<zx_status_t(::llcpp::fuchsia::io2::ConnectionInfo info)> on_connection_info;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ };
+
+ // 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:
+ class Reopen_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Reopen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+ ~Reopen_Impl() = default;
+ Reopen_Impl(Reopen_Impl&& other) = default;
+ Reopen_Impl& operator=(Reopen_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 GetToken_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetToken_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetToken_Impl() = default;
+ GetToken_Impl(GetToken_Impl&& other) = default;
+ GetToken_Impl& operator=(GetToken_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 GetAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+ ~GetAttributes_Impl() = default;
+ GetAttributes_Impl(GetAttributes_Impl&& other) = default;
+ GetAttributes_Impl& operator=(GetAttributes_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 UpdateAttributes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UpdateAttributes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~UpdateAttributes_Impl() = default;
+ UpdateAttributes_Impl(UpdateAttributes_Impl&& other) = default;
+ UpdateAttributes_Impl& operator=(UpdateAttributes_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 Reopen = Reopen_Impl;
+ using Close = Close_Impl;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using GetToken = GetToken_Impl<GetTokenResponse>;
+ using GetAttributes = GetAttributes_Impl<GetAttributesResponse>;
+ using UpdateAttributes = UpdateAttributes_Impl<UpdateAttributesResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ };
+
+ 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_; }
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Reopen Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Reopen Reopen(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::Describe Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetToken GetToken();
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetToken GetToken(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetAttributes GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttributes GetAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UpdateAttributes UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UpdateAttributes UpdateAttributes(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Allocates 112 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Reopen Reopen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::ConnectionInfoQuery query);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::ConnectionInfoQuery query, ::fidl::BytePart _response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetToken GetToken(::zx::unowned_channel _client_end);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetToken GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributesQuery query);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttributes GetAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributesQuery query, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Allocates 272 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UpdateAttributes UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Creates another connection to the same node.
+ //
+ // + `options` options applicable to both `Open` and `Reopen`,
+ // including negotiating protocol and restricting rights.
+ // See [`fuchsia.io2/ConnectionOptions`].
+ // + `object_request` is the server end of a channel created for the new
+ // connection. The caller may proceed to send messages on the
+ // corresponding client end right away.
+ //
+ // For files, the cloned connection and the original connection have
+ // independent seek offsets.
+ static ::fidl::internal::StatusAndError Reopen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReopenRequest> params);
+
+ // Terminates the connection to the node.
+ //
+ // After calling `Close`, the client must not send any other requests.
+ // The result of `Close` arrives as an epitaph, where the channel is closed
+ // by the server upon processing this operation.
+ //
+ // Closing the client end of the channel should be semantically equivalent
+ // to calling `Close` without monitoring the status epitaph.
+ //
+ // This method does not require any rights.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ // Returns extra connection information and auxiliary handles.
+ //
+ // + `query` specifies the fields in `ConnectionInfo` that the caller is
+ // interested in.
+ // - `info` see [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ //
+ // When all known bits in `query` are set, the return value matches
+ // the one from [`OnConnectionInfo`], as if the caller requested that event
+ // using [`ConnectionFlags.GET_CONNECTION_INFO`].
+ //
+ // If the `Describe` operation fails, the connection is closed with the
+ // associated error.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DescribeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires a token which can be used to identify this connection at
+ // a later point in time.
+ //
+ // This method does not require any rights. Note that the token identifies
+ // the connection, hence carries the rights information on this connection.
+ static ::fidl::DecodeResult<GetTokenResponse> GetToken(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // The attributes of a node should be stable, independent of the
+ // specific protocol used to access it.
+ //
+ // + `query` a bit-mask specifying which attributes to fetch. The server
+ // should not return more than necessary.
+ // - `attributes` the returned attributes.
+ //
+ // This method requires the [`Rights.GET_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<GetAttributesResponse> GetAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ //
+ // + `attributes` the presence of a table field in `attributes` indicates
+ // the intent to update the corresponding attribute.
+ //
+ // This method requires the [`Rights.UPDATE_ATTRIBUTES`] right.
+ static ::fidl::DecodeResult<UpdateAttributesResponse> UpdateAttributes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UpdateAttributesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method will return when the filesystem server has flushed the
+ // relevant updates to the underlying media, but does not guarantee the
+ // underlying media has persisted the information, nor that any information
+ // is committed to hardware. Clients may use `Sync` to ensure ordering
+ // between operations.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::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 = Debuglog;
+ using _Base = ::fidl::CompleterBase;
+
+ using ReopenCompleter = ::fidl::Completer<>;
+
+ virtual void Reopen(::llcpp::fuchsia::io2::ConnectionOptions options, ::zx::channel object_request, ReopenCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(::llcpp::fuchsia::io2::ConnectionInfoQuery query, DescribeCompleter::Sync _completer) = 0;
+
+ class GetTokenCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::zx::handle token);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetToken_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::handle token);
+ void Reply(::fidl::DecodedMessage<GetTokenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetTokenCompleter = ::fidl::Completer<GetTokenCompleterBase>;
+
+ virtual void GetToken(GetTokenCompleter::Sync _completer) = 0;
+
+ class GetAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_GetAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttributesCompleter = ::fidl::Completer<GetAttributesCompleterBase>;
+
+ virtual void GetAttributes(::llcpp::fuchsia::io2::NodeAttributesQuery query, GetAttributesCompleter::Sync _completer) = 0;
+
+ class UpdateAttributesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_UpdateAttributes_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<UpdateAttributesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UpdateAttributesCompleter = ::fidl::Completer<UpdateAttributesCompleterBase>;
+
+ virtual void UpdateAttributes(::llcpp::fuchsia::io2::NodeAttributes attributes, UpdateAttributesCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::Node_Sync_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::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);
+ }
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::llcpp::fuchsia::io2::ConnectionInfo info);
+
+ // An event produced eagerly by the server if requested by
+ // [`ConnectionFlags.GET_CONNECTION_INFO`]. This event will be the
+ // first message from the server, and is sent exactly once.
+ //
+ // - `info` See [`fuchsia.io2/ConnectionInfo`] for details on the fields.
+ // All members should be present.
+ //
+ // Different from [`fuchsia.io/OnOpen`], an error during open/reopen is
+ // always manifested as an epitaph.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnConnectionInfoEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnConnectionInfoResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void ReopenRequest(const ::fidl::DecodedMessage<Debuglog::ReopenRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Debuglog::CloseRequest>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Debuglog::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Debuglog::DescribeResponse>& _msg);
+ static void OnConnectionInfoResponse(const ::fidl::DecodedMessage<Debuglog::OnConnectionInfoResponse>& _msg);
+ static void GetTokenRequest(const ::fidl::DecodedMessage<Debuglog::GetTokenRequest>& _msg);
+ static void GetTokenResponse(const ::fidl::DecodedMessage<Debuglog::GetTokenResponse>& _msg);
+ static void GetAttributesRequest(const ::fidl::DecodedMessage<Debuglog::GetAttributesRequest>& _msg);
+ static void GetAttributesResponse(const ::fidl::DecodedMessage<Debuglog::GetAttributesResponse>& _msg);
+ static void UpdateAttributesRequest(const ::fidl::DecodedMessage<Debuglog::UpdateAttributesRequest>& _msg);
+ static void UpdateAttributesResponse(const ::fidl::DecodedMessage<Debuglog::UpdateAttributesResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Debuglog::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Debuglog::SyncResponse>& _msg);
+ };
+};
+
+} // namespace io2
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::MemoryInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::MemoryInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_GetMemRange_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_GetMemRange_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::File_GetMemRange_Response, buffer) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::File_GetMemRange_Response) == ::llcpp::fuchsia::io2::File_GetMemRange_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_GetMemRange_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_GetMemRange_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::VmoFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::VmoFlags>);
+static_assert(sizeof(::llcpp::fuchsia::io2::VmoFlags) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::TtyInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::TtyInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_Read_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_Read_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::File_Read_Response, data) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::File_Read_Response) == ::llcpp::fuchsia::io2::File_Read_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_Read_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_Read_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_ReadAt_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_ReadAt_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::File_ReadAt_Response, data) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::File_ReadAt_Response) == ::llcpp::fuchsia::io2::File_ReadAt_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_ReadAt_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_ReadAt_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node_GetToken_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Node_GetToken_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node_GetToken_Response, token) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::Node_GetToken_Response) == ::llcpp::fuchsia::io2::Node_GetToken_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node_GetToken_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Node_GetToken_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::PosixSocketInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::PosixSocketInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::PipeInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::PipeInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Operations> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Operations>);
+static_assert(sizeof(::llcpp::fuchsia::io2::Operations) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node_UpdateAttributes_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Node_UpdateAttributes_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node_UpdateAttributes_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::Node_UpdateAttributes_Response) == ::llcpp::fuchsia::io2::Node_UpdateAttributes_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node_UpdateAttributes_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Node_UpdateAttributes_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node_Sync_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Node_Sync_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node_Sync_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::Node_Sync_Response) == ::llcpp::fuchsia::io2::Node_Sync_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node_Sync_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Node_Sync_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::NodeProtocolSet> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::NodeProtocolSet>);
+static_assert(sizeof(::llcpp::fuchsia::io2::NodeProtocolSet) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::NodeAttributesQuery> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::NodeAttributesQuery>);
+static_assert(sizeof(::llcpp::fuchsia::io2::NodeAttributesQuery) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::IdleEvent> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::IdleEvent>);
+static_assert(offsetof(::llcpp::fuchsia::io2::IdleEvent, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::IdleEvent) == ::llcpp::fuchsia::io2::IdleEvent::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::NodeAttributes> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::NodeAttributes>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node_GetAttributes_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Node_GetAttributes_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node_GetAttributes_Response, attributes) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::Node_GetAttributes_Response) == ::llcpp::fuchsia::io2::Node_GetAttributes_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node_GetAttributes_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Node_GetAttributes_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryEntry> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DirectoryEntry>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryWatchedEvent> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DirectoryWatchedEvent>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryWatcher::GetNextResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::DirectoryWatcher::GetNextResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::DirectoryWatcher::GetNextResponse)
+ == ::llcpp::fuchsia::io2::DirectoryWatcher::GetNextResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::DirectoryWatcher::GetNextResponse, events) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response, entries) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response) == ::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DirectoryIterator_GetNext_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryIterator::GetNextResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::DirectoryIterator::GetNextResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::DirectoryIterator::GetNextResponse)
+ == ::llcpp::fuchsia::io2::DirectoryIterator::GetNextResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::DirectoryIterator::GetNextResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_Write_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_Write_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::File_Write_Response, actual_count) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::File_Write_Response) == ::llcpp::fuchsia::io2::File_Write_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_Write_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_Write_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_WriteAt_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_WriteAt_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::File_WriteAt_Response, actual_count) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::File_WriteAt_Response) == ::llcpp::fuchsia::io2::File_WriteAt_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_WriteAt_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_WriteAt_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_Seek_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_Seek_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::File_Seek_Response, offset_from_start) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::File_Seek_Response) == ::llcpp::fuchsia::io2::File_Seek_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_Seek_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_Seek_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_Resize_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_Resize_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::File_Resize_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::File_Resize_Response) == ::llcpp::fuchsia::io2::File_Resize_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File_Resize_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::File_Resize_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::FileSignal> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::FileSignal>);
+static_assert(sizeof(::llcpp::fuchsia::io2::FileSignal) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::FileInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::FileInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory_Unlink_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Directory_Unlink_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory_Unlink_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory_Unlink_Response) == ::llcpp::fuchsia::io2::Directory_Unlink_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory_Unlink_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Directory_Unlink_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory_Rename_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Directory_Rename_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory_Rename_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory_Rename_Response) == ::llcpp::fuchsia::io2::Directory_Rename_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory_Rename_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Directory_Rename_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory_Link_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Directory_Link_Response>);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory_Link_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory_Link_Response) == ::llcpp::fuchsia::io2::Directory_Link_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory_Link_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Directory_Link_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryWatchOptions> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DirectoryWatchOptions>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryWatchMask> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DirectoryWatchMask>);
+static_assert(sizeof(::llcpp::fuchsia::io2::DirectoryWatchMask) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DirectoryInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DirectoryEnumerateOptions> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DirectoryEnumerateOptions>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DeviceSignal> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DeviceSignal>);
+static_assert(sizeof(::llcpp::fuchsia::io2::DeviceSignal) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DeviceInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DeviceInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::DebuglogInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::DebuglogInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::ConnectorInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::ConnectorInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Representation> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::Representation>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::ConnectionInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::ConnectionInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::ConnectionInfoQuery> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::ConnectionInfoQuery>);
+static_assert(sizeof(::llcpp::fuchsia::io2::ConnectionInfoQuery) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::ConnectionFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::ConnectionFlags>);
+static_assert(sizeof(::llcpp::fuchsia::io2::ConnectionFlags) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::ConnectionOptions> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::io2::ConnectionOptions>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::ReopenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::ReopenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::ReopenRequest)
+ == ::llcpp::fuchsia::io2::Node::ReopenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::ReopenRequest, options) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::ReopenRequest, object_request) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::DescribeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::DescribeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::DescribeRequest)
+ == ::llcpp::fuchsia::io2::Node::DescribeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::DescribeRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::DescribeResponse)
+ == ::llcpp::fuchsia::io2::Node::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::OnConnectionInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::OnConnectionInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::OnConnectionInfoResponse)
+ == ::llcpp::fuchsia::io2::Node::OnConnectionInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::OnConnectionInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::GetTokenResponse)
+ == ::llcpp::fuchsia::io2::Node::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::GetTokenResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::GetAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::GetAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::GetAttributesRequest)
+ == ::llcpp::fuchsia::io2::Node::GetAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::GetAttributesRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::GetAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::GetAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::GetAttributesResponse)
+ == ::llcpp::fuchsia::io2::Node::GetAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::GetAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::UpdateAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::UpdateAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::UpdateAttributesRequest)
+ == ::llcpp::fuchsia::io2::Node::UpdateAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::UpdateAttributesRequest, attributes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::UpdateAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::UpdateAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::UpdateAttributesResponse)
+ == ::llcpp::fuchsia::io2::Node::UpdateAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::UpdateAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Node::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Node::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Node::SyncResponse)
+ == ::llcpp::fuchsia::io2::Node::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Node::SyncResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::ReopenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::ReopenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::ReopenRequest)
+ == ::llcpp::fuchsia::io2::Pipe::ReopenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::ReopenRequest, options) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::ReopenRequest, object_request) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::DescribeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::DescribeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::DescribeRequest)
+ == ::llcpp::fuchsia::io2::Pipe::DescribeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::DescribeRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::DescribeResponse)
+ == ::llcpp::fuchsia::io2::Pipe::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::OnConnectionInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::OnConnectionInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::OnConnectionInfoResponse)
+ == ::llcpp::fuchsia::io2::Pipe::OnConnectionInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::OnConnectionInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::GetTokenResponse)
+ == ::llcpp::fuchsia::io2::Pipe::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::GetTokenResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::GetAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::GetAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::GetAttributesRequest)
+ == ::llcpp::fuchsia::io2::Pipe::GetAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::GetAttributesRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::GetAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::GetAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::GetAttributesResponse)
+ == ::llcpp::fuchsia::io2::Pipe::GetAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::GetAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::UpdateAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::UpdateAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::UpdateAttributesRequest)
+ == ::llcpp::fuchsia::io2::Pipe::UpdateAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::UpdateAttributesRequest, attributes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::UpdateAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::UpdateAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::UpdateAttributesResponse)
+ == ::llcpp::fuchsia::io2::Pipe::UpdateAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::UpdateAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Pipe::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Pipe::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Pipe::SyncResponse)
+ == ::llcpp::fuchsia::io2::Pipe::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Pipe::SyncResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::ReopenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::ReopenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::ReopenRequest)
+ == ::llcpp::fuchsia::io2::Memory::ReopenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::ReopenRequest, options) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::ReopenRequest, object_request) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::DescribeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::DescribeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::DescribeRequest)
+ == ::llcpp::fuchsia::io2::Memory::DescribeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::DescribeRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::DescribeResponse)
+ == ::llcpp::fuchsia::io2::Memory::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::OnConnectionInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::OnConnectionInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::OnConnectionInfoResponse)
+ == ::llcpp::fuchsia::io2::Memory::OnConnectionInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::OnConnectionInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::GetTokenResponse)
+ == ::llcpp::fuchsia::io2::Memory::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::GetTokenResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::GetAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::GetAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::GetAttributesRequest)
+ == ::llcpp::fuchsia::io2::Memory::GetAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::GetAttributesRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::GetAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::GetAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::GetAttributesResponse)
+ == ::llcpp::fuchsia::io2::Memory::GetAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::GetAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::UpdateAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::UpdateAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::UpdateAttributesRequest)
+ == ::llcpp::fuchsia::io2::Memory::UpdateAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::UpdateAttributesRequest, attributes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::UpdateAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::UpdateAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::UpdateAttributesResponse)
+ == ::llcpp::fuchsia::io2::Memory::UpdateAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::UpdateAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Memory::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Memory::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Memory::SyncResponse)
+ == ::llcpp::fuchsia::io2::Memory::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Memory::SyncResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::ReopenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::ReopenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::ReopenRequest)
+ == ::llcpp::fuchsia::io2::File::ReopenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ReopenRequest, options) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ReopenRequest, object_request) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::DescribeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::DescribeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::DescribeRequest)
+ == ::llcpp::fuchsia::io2::File::DescribeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::DescribeRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::DescribeResponse)
+ == ::llcpp::fuchsia::io2::File::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::OnConnectionInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::OnConnectionInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::OnConnectionInfoResponse)
+ == ::llcpp::fuchsia::io2::File::OnConnectionInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::OnConnectionInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::GetTokenResponse)
+ == ::llcpp::fuchsia::io2::File::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::GetTokenResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::GetAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::GetAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::GetAttributesRequest)
+ == ::llcpp::fuchsia::io2::File::GetAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::GetAttributesRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::GetAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::GetAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::GetAttributesResponse)
+ == ::llcpp::fuchsia::io2::File::GetAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::GetAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::UpdateAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::UpdateAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::UpdateAttributesRequest)
+ == ::llcpp::fuchsia::io2::File::UpdateAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::UpdateAttributesRequest, attributes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::UpdateAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::UpdateAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::UpdateAttributesResponse)
+ == ::llcpp::fuchsia::io2::File::UpdateAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::UpdateAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::SyncResponse)
+ == ::llcpp::fuchsia::io2::File::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::SyncResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::SeekRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::SeekRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::SeekRequest)
+ == ::llcpp::fuchsia::io2::File::SeekRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::SeekRequest, origin) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::SeekRequest, offset) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::SeekResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::SeekResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::SeekResponse)
+ == ::llcpp::fuchsia::io2::File::SeekResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::SeekResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::ReadRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::ReadRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::ReadRequest)
+ == ::llcpp::fuchsia::io2::File::ReadRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ReadRequest, count) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::ReadResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::ReadResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::ReadResponse)
+ == ::llcpp::fuchsia::io2::File::ReadResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ReadResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::WriteRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::WriteRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::WriteRequest)
+ == ::llcpp::fuchsia::io2::File::WriteRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::WriteRequest, data) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::WriteResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::WriteResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::WriteResponse)
+ == ::llcpp::fuchsia::io2::File::WriteResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::WriteResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::ReadAtRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::ReadAtRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::ReadAtRequest)
+ == ::llcpp::fuchsia::io2::File::ReadAtRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ReadAtRequest, count) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ReadAtRequest, offset) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::ReadAtResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::ReadAtResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::ReadAtResponse)
+ == ::llcpp::fuchsia::io2::File::ReadAtResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ReadAtResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::WriteAtRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::WriteAtRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::WriteAtRequest)
+ == ::llcpp::fuchsia::io2::File::WriteAtRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::WriteAtRequest, data) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::WriteAtRequest, offset) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::WriteAtResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::WriteAtResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::WriteAtResponse)
+ == ::llcpp::fuchsia::io2::File::WriteAtResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::WriteAtResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::ResizeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::ResizeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::ResizeRequest)
+ == ::llcpp::fuchsia::io2::File::ResizeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ResizeRequest, length) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::ResizeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::ResizeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::ResizeResponse)
+ == ::llcpp::fuchsia::io2::File::ResizeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::ResizeResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::GetMemRangeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::GetMemRangeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::GetMemRangeRequest)
+ == ::llcpp::fuchsia::io2::File::GetMemRangeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::GetMemRangeRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::File::GetMemRangeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::File::GetMemRangeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::File::GetMemRangeResponse)
+ == ::llcpp::fuchsia::io2::File::GetMemRangeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::File::GetMemRangeResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::ReopenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::ReopenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::ReopenRequest)
+ == ::llcpp::fuchsia::io2::Directory::ReopenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::ReopenRequest, options) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::ReopenRequest, object_request) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::DescribeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::DescribeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::DescribeRequest)
+ == ::llcpp::fuchsia::io2::Directory::DescribeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::DescribeRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::DescribeResponse)
+ == ::llcpp::fuchsia::io2::Directory::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::OnConnectionInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::OnConnectionInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::OnConnectionInfoResponse)
+ == ::llcpp::fuchsia::io2::Directory::OnConnectionInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::OnConnectionInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::GetTokenResponse)
+ == ::llcpp::fuchsia::io2::Directory::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::GetTokenResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::GetAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::GetAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::GetAttributesRequest)
+ == ::llcpp::fuchsia::io2::Directory::GetAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::GetAttributesRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::GetAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::GetAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::GetAttributesResponse)
+ == ::llcpp::fuchsia::io2::Directory::GetAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::GetAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::UpdateAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::UpdateAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::UpdateAttributesRequest)
+ == ::llcpp::fuchsia::io2::Directory::UpdateAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::UpdateAttributesRequest, attributes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::UpdateAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::UpdateAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::UpdateAttributesResponse)
+ == ::llcpp::fuchsia::io2::Directory::UpdateAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::UpdateAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::SyncResponse)
+ == ::llcpp::fuchsia::io2::Directory::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::SyncResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::OpenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::OpenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::OpenRequest)
+ == ::llcpp::fuchsia::io2::Directory::OpenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::OpenRequest, path) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::OpenRequest, mode) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::OpenRequest, options) == 40);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::OpenRequest, object_request) == 56);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::UnlinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::UnlinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::UnlinkRequest)
+ == ::llcpp::fuchsia::io2::Directory::UnlinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::UnlinkRequest, path) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::UnlinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::UnlinkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::UnlinkResponse)
+ == ::llcpp::fuchsia::io2::Directory::UnlinkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::UnlinkResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::EnumerateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::EnumerateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::EnumerateRequest)
+ == ::llcpp::fuchsia::io2::Directory::EnumerateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::EnumerateRequest, options) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::EnumerateRequest, iterator) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::RenameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::RenameRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::RenameRequest)
+ == ::llcpp::fuchsia::io2::Directory::RenameRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::RenameRequest, src) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::RenameRequest, dst_parent_token) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::RenameRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::RenameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::RenameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::RenameResponse)
+ == ::llcpp::fuchsia::io2::Directory::RenameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::RenameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::LinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::LinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::LinkRequest)
+ == ::llcpp::fuchsia::io2::Directory::LinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::LinkRequest, src) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::LinkRequest, dst_parent_token) == 32);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::LinkRequest, dst) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::LinkResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::LinkResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::LinkResponse)
+ == ::llcpp::fuchsia::io2::Directory::LinkResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::LinkResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Directory::WatchRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Directory::WatchRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Directory::WatchRequest)
+ == ::llcpp::fuchsia::io2::Directory::WatchRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::WatchRequest, mask) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::WatchRequest, options) == 24);
+static_assert(offsetof(::llcpp::fuchsia::io2::Directory::WatchRequest, watcher) == 40);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::ReopenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::ReopenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::ReopenRequest)
+ == ::llcpp::fuchsia::io2::Debuglog::ReopenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::ReopenRequest, options) == 16);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::ReopenRequest, object_request) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::DescribeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::DescribeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::DescribeRequest)
+ == ::llcpp::fuchsia::io2::Debuglog::DescribeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::DescribeRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::DescribeResponse)
+ == ::llcpp::fuchsia::io2::Debuglog::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::OnConnectionInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::OnConnectionInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::OnConnectionInfoResponse)
+ == ::llcpp::fuchsia::io2::Debuglog::OnConnectionInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::OnConnectionInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::GetTokenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::GetTokenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::GetTokenResponse)
+ == ::llcpp::fuchsia::io2::Debuglog::GetTokenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::GetTokenResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::GetAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::GetAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::GetAttributesRequest)
+ == ::llcpp::fuchsia::io2::Debuglog::GetAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::GetAttributesRequest, query) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::GetAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::GetAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::GetAttributesResponse)
+ == ::llcpp::fuchsia::io2::Debuglog::GetAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::GetAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::UpdateAttributesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::UpdateAttributesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::UpdateAttributesRequest)
+ == ::llcpp::fuchsia::io2::Debuglog::UpdateAttributesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::UpdateAttributesRequest, attributes) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::UpdateAttributesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::UpdateAttributesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::UpdateAttributesResponse)
+ == ::llcpp::fuchsia::io2::Debuglog::UpdateAttributesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::UpdateAttributesResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::io2::Debuglog::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::io2::Debuglog::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::io2::Debuglog::SyncResponse)
+ == ::llcpp::fuchsia::io2::Debuglog::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::io2::Debuglog::SyncResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-kernel/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-kernel/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..217b5cb
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-kernel/gen/llcpp/fidl.cc
@@ -0,0 +1,1241 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/kernel/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace kernel {
+
+::llcpp::fuchsia::kernel::PerCpuStats::Builder PerCpuStats::Build() {
+ return PerCpuStats::Builder();
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_cpu_number(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_flags(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_idle_time(int64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_reschedules(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_context_switches(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_irq_preempts(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[6 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 6) {
+ max_ordinal_ = 6;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_yields(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[7 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 7) {
+ max_ordinal_ = 7;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_ints(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[8 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 8) {
+ max_ordinal_ = 8;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_timer_ints(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[9 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 9) {
+ max_ordinal_ = 9;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_timers(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[10 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 10) {
+ max_ordinal_ = 10;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_page_faults(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[11 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 11) {
+ max_ordinal_ = 11;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_exceptions(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[12 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 12) {
+ max_ordinal_ = 12;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_syscalls(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[13 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 13) {
+ max_ordinal_ = 13;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_reschedule_ipis(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[14 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 14) {
+ max_ordinal_ = 14;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::PerCpuStats::Builder::set_generic_ipis(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[15 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 15) {
+ max_ordinal_ = 15;
+ }
+ return std::move(*this);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kMexecBroker_PerformMexec_Ordinal = 0x2db06f5f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMexecBroker_PerformMexec_GenOrdinal = 0x191f56222830486flu;
+extern "C" const fidl_type_t v1_fuchsia_kernel_MexecBrokerPerformMexecRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_MexecBrokerPerformMexecResponseTable;
+
+} // namespace
+
+MexecBroker::ResultOf::PerformMexec_Impl::PerformMexec_Impl(::zx::unowned_channel _client_end, ::zx::vmo kernel, ::zx::vmo bootdata) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<PerformMexecRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, PerformMexecRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<PerformMexecRequest*>(_write_bytes);
+ _request.kernel = std::move(kernel);
+ _request.bootdata = std::move(bootdata);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(PerformMexecRequest));
+ ::fidl::DecodedMessage<PerformMexecRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ MexecBroker::InPlace::PerformMexec(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MexecBroker::ResultOf::PerformMexec MexecBroker::SyncClient::PerformMexec(::zx::vmo kernel, ::zx::vmo bootdata) {
+ return ResultOf::PerformMexec(::zx::unowned_channel(this->channel_), std::move(kernel), std::move(bootdata));
+}
+
+MexecBroker::ResultOf::PerformMexec MexecBroker::Call::PerformMexec(::zx::unowned_channel _client_end, ::zx::vmo kernel, ::zx::vmo bootdata) {
+ return ResultOf::PerformMexec(std::move(_client_end), std::move(kernel), std::move(bootdata));
+}
+
+
+MexecBroker::UnownedResultOf::PerformMexec_Impl::PerformMexec_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) {
+ if (_request_buffer.capacity() < PerformMexecRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, PerformMexecRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<PerformMexecRequest*>(_request_buffer.data());
+ _request.kernel = std::move(kernel);
+ _request.bootdata = std::move(bootdata);
+ _request_buffer.set_actual(sizeof(PerformMexecRequest));
+ ::fidl::DecodedMessage<PerformMexecRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ MexecBroker::InPlace::PerformMexec(std::move(_client_end), std::move(_decoded_request)));
+}
+
+MexecBroker::UnownedResultOf::PerformMexec MexecBroker::SyncClient::PerformMexec(::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) {
+ return UnownedResultOf::PerformMexec(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(kernel), std::move(bootdata));
+}
+
+MexecBroker::UnownedResultOf::PerformMexec MexecBroker::Call::PerformMexec(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata) {
+ return UnownedResultOf::PerformMexec(std::move(_client_end), std::move(_request_buffer), std::move(kernel), std::move(bootdata));
+}
+
+::fidl::internal::StatusAndError MexecBroker::InPlace::PerformMexec(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PerformMexecRequest> params) {
+ MexecBroker::SetTransactionHeaderFor::PerformMexecRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool MexecBroker::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kMexecBroker_PerformMexec_Ordinal:
+ case kMexecBroker_PerformMexec_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<PerformMexecRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->PerformMexec(std::move(message->kernel), std::move(message->bootdata),
+ Interface::PerformMexecCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool MexecBroker::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void MexecBroker::SetTransactionHeaderFor::PerformMexecRequest(const ::fidl::DecodedMessage<MexecBroker::PerformMexecRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMexecBroker_PerformMexec_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDebugBroker_SendDebugCommand_Ordinal = 0x3f05f48400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebugBroker_SendDebugCommand_GenOrdinal = 0x1ee270f83b5d6ff6lu;
+extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSendDebugCommandRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSendDebugCommandResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDebugBroker_SetTracingEnabled_Ordinal = 0x273cf2d900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDebugBroker_SetTracingEnabled_GenOrdinal = 0x12e368d05329b30elu;
+extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSetTracingEnabledRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSetTracingEnabledResponseTable;
+
+} // namespace
+template <>
+DebugBroker::ResultOf::SendDebugCommand_Impl<DebugBroker::SendDebugCommandResponse>::SendDebugCommand_Impl(::zx::unowned_channel _client_end, ::fidl::StringView command) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SendDebugCommandRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SendDebugCommandRequest _request = {};
+ _request.command = std::move(command);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SendDebugCommandRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DebugBroker::InPlace::SendDebugCommand(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DebugBroker::ResultOf::SendDebugCommand DebugBroker::SyncClient::SendDebugCommand(::fidl::StringView command) {
+ return ResultOf::SendDebugCommand(::zx::unowned_channel(this->channel_), std::move(command));
+}
+
+DebugBroker::ResultOf::SendDebugCommand DebugBroker::Call::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::StringView command) {
+ return ResultOf::SendDebugCommand(std::move(_client_end), std::move(command));
+}
+
+template <>
+DebugBroker::UnownedResultOf::SendDebugCommand_Impl<DebugBroker::SendDebugCommandResponse>::SendDebugCommand_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SendDebugCommandRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SendDebugCommandResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SendDebugCommandRequest _request = {};
+ _request.command = std::move(command);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SendDebugCommandRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DebugBroker::InPlace::SendDebugCommand(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DebugBroker::UnownedResultOf::SendDebugCommand DebugBroker::SyncClient::SendDebugCommand(::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SendDebugCommand(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(command), std::move(_response_buffer));
+}
+
+DebugBroker::UnownedResultOf::SendDebugCommand DebugBroker::Call::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SendDebugCommand(std::move(_client_end), std::move(_request_buffer), std::move(command), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse> DebugBroker::InPlace::SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SendDebugCommandRequest> params, ::fidl::BytePart response_buffer) {
+ DebugBroker::SetTransactionHeaderFor::SendDebugCommandRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SendDebugCommandRequest, SendDebugCommandResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugBroker::SendDebugCommandResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DebugBroker::ResultOf::SetTracingEnabled_Impl<DebugBroker::SetTracingEnabledResponse>::SetTracingEnabled_Impl(::zx::unowned_channel _client_end, bool enabled) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTracingEnabledRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetTracingEnabledRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetTracingEnabledRequest*>(_write_bytes);
+ _request.enabled = std::move(enabled);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTracingEnabledRequest));
+ ::fidl::DecodedMessage<SetTracingEnabledRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DebugBroker::InPlace::SetTracingEnabled(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DebugBroker::ResultOf::SetTracingEnabled DebugBroker::SyncClient::SetTracingEnabled(bool enabled) {
+ return ResultOf::SetTracingEnabled(::zx::unowned_channel(this->channel_), std::move(enabled));
+}
+
+DebugBroker::ResultOf::SetTracingEnabled DebugBroker::Call::SetTracingEnabled(::zx::unowned_channel _client_end, bool enabled) {
+ return ResultOf::SetTracingEnabled(std::move(_client_end), std::move(enabled));
+}
+
+template <>
+DebugBroker::UnownedResultOf::SetTracingEnabled_Impl<DebugBroker::SetTracingEnabledResponse>::SetTracingEnabled_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetTracingEnabledRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetTracingEnabledResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetTracingEnabledRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetTracingEnabledRequest*>(_request_buffer.data());
+ _request.enabled = std::move(enabled);
+ _request_buffer.set_actual(sizeof(SetTracingEnabledRequest));
+ ::fidl::DecodedMessage<SetTracingEnabledRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DebugBroker::InPlace::SetTracingEnabled(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DebugBroker::UnownedResultOf::SetTracingEnabled DebugBroker::SyncClient::SetTracingEnabled(::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetTracingEnabled(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer));
+}
+
+DebugBroker::UnownedResultOf::SetTracingEnabled DebugBroker::Call::SetTracingEnabled(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetTracingEnabled(std::move(_client_end), std::move(_request_buffer), std::move(enabled), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse> DebugBroker::InPlace::SetTracingEnabled(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTracingEnabledRequest> params, ::fidl::BytePart response_buffer) {
+ DebugBroker::SetTransactionHeaderFor::SetTracingEnabledRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetTracingEnabledRequest, SetTracingEnabledResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DebugBroker::SetTracingEnabledResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DebugBroker::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDebugBroker_SendDebugCommand_Ordinal:
+ case kDebugBroker_SendDebugCommand_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SendDebugCommandRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SendDebugCommand(std::move(message->command),
+ Interface::SendDebugCommandCompleter::Sync(txn));
+ return true;
+ }
+ case kDebugBroker_SetTracingEnabled_Ordinal:
+ case kDebugBroker_SetTracingEnabled_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetTracingEnabledRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetTracingEnabled(std::move(message->enabled),
+ Interface::SetTracingEnabledCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DebugBroker::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SendDebugCommandResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SendDebugCommandResponse*>(_write_bytes);
+ DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(
+ ::fidl::DecodedMessage<SendDebugCommandResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SendDebugCommandResponse::PrimarySize,
+ SendDebugCommandResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SendDebugCommandResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SendDebugCommandResponse>(std::move(_response_bytes)));
+}
+
+void DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SendDebugCommandResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SendDebugCommandResponse*>(_buffer.data());
+ DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(
+ ::fidl::DecodedMessage<SendDebugCommandResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SendDebugCommandResponse::PrimarySize,
+ SendDebugCommandResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SendDebugCommandResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SendDebugCommandResponse>(std::move(_buffer)));
+}
+
+void DebugBroker::Interface::SendDebugCommandCompleterBase::Reply(::fidl::DecodedMessage<SendDebugCommandResponse> params) {
+ DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetTracingEnabledResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetTracingEnabledResponse*>(_write_bytes);
+ DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(
+ ::fidl::DecodedMessage<SetTracingEnabledResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetTracingEnabledResponse::PrimarySize,
+ SetTracingEnabledResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetTracingEnabledResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetTracingEnabledResponse>(std::move(_response_bytes)));
+}
+
+void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetTracingEnabledResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetTracingEnabledResponse*>(_buffer.data());
+ DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(
+ ::fidl::DecodedMessage<SetTracingEnabledResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetTracingEnabledResponse::PrimarySize,
+ SetTracingEnabledResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetTracingEnabledResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetTracingEnabledResponse>(std::move(_buffer)));
+}
+
+void DebugBroker::Interface::SetTracingEnabledCompleterBase::Reply(::fidl::DecodedMessage<SetTracingEnabledResponse> params) {
+ DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DebugBroker::SetTransactionHeaderFor::SendDebugCommandRequest(const ::fidl::DecodedMessage<DebugBroker::SendDebugCommandRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SendDebugCommand_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DebugBroker::SetTransactionHeaderFor::SendDebugCommandResponse(const ::fidl::DecodedMessage<DebugBroker::SendDebugCommandResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SendDebugCommand_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DebugBroker::SetTransactionHeaderFor::SetTracingEnabledRequest(const ::fidl::DecodedMessage<DebugBroker::SetTracingEnabledRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SetTracingEnabled_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DebugBroker::SetTransactionHeaderFor::SetTracingEnabledResponse(const ::fidl::DecodedMessage<DebugBroker::SetTracingEnabledResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDebugBroker_SetTracingEnabled_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kCounter_GetInspectVmo_Ordinal = 0x1ba5957d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCounter_GetInspectVmo_GenOrdinal = 0x6ea9b2e6b2791b81lu;
+extern "C" const fidl_type_t v1_fuchsia_kernel_CounterGetInspectVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_CounterGetInspectVmoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kCounter_UpdateInspectVmo_Ordinal = 0x4556672400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kCounter_UpdateInspectVmo_GenOrdinal = 0x1d25eb7995a0539flu;
+extern "C" const fidl_type_t v1_fuchsia_kernel_CounterUpdateInspectVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_CounterUpdateInspectVmoResponseTable;
+
+} // namespace
+template <>
+Counter::ResultOf::GetInspectVmo_Impl<Counter::GetInspectVmoResponse>::GetInspectVmo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInspectVmoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInspectVmoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInspectVmoRequest));
+ ::fidl::DecodedMessage<GetInspectVmoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Counter::InPlace::GetInspectVmo(std::move(_client_end), Super::response_buffer()));
+}
+
+Counter::ResultOf::GetInspectVmo Counter::SyncClient::GetInspectVmo() {
+ return ResultOf::GetInspectVmo(::zx::unowned_channel(this->channel_));
+}
+
+Counter::ResultOf::GetInspectVmo Counter::Call::GetInspectVmo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInspectVmo(std::move(_client_end));
+}
+
+template <>
+Counter::UnownedResultOf::GetInspectVmo_Impl<Counter::GetInspectVmoResponse>::GetInspectVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInspectVmoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInspectVmoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInspectVmoRequest));
+ ::fidl::DecodedMessage<GetInspectVmoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Counter::InPlace::GetInspectVmo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Counter::UnownedResultOf::GetInspectVmo Counter::SyncClient::GetInspectVmo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInspectVmo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Counter::UnownedResultOf::GetInspectVmo Counter::Call::GetInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInspectVmo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Counter::GetInspectVmoResponse> Counter::InPlace::GetInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInspectVmoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInspectVmoRequest> params(std::move(_request_buffer));
+ Counter::SetTransactionHeaderFor::GetInspectVmoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Counter::GetInspectVmoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInspectVmoRequest, GetInspectVmoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Counter::GetInspectVmoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Counter::ResultOf::UpdateInspectVmo_Impl<Counter::UpdateInspectVmoResponse>::UpdateInspectVmo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateInspectVmoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, UpdateInspectVmoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UpdateInspectVmoRequest));
+ ::fidl::DecodedMessage<UpdateInspectVmoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Counter::InPlace::UpdateInspectVmo(std::move(_client_end), Super::response_buffer()));
+}
+
+Counter::ResultOf::UpdateInspectVmo Counter::SyncClient::UpdateInspectVmo() {
+ return ResultOf::UpdateInspectVmo(::zx::unowned_channel(this->channel_));
+}
+
+Counter::ResultOf::UpdateInspectVmo Counter::Call::UpdateInspectVmo(::zx::unowned_channel _client_end) {
+ return ResultOf::UpdateInspectVmo(std::move(_client_end));
+}
+
+template <>
+Counter::UnownedResultOf::UpdateInspectVmo_Impl<Counter::UpdateInspectVmoResponse>::UpdateInspectVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(UpdateInspectVmoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, UpdateInspectVmoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(UpdateInspectVmoRequest));
+ ::fidl::DecodedMessage<UpdateInspectVmoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Counter::InPlace::UpdateInspectVmo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Counter::UnownedResultOf::UpdateInspectVmo Counter::SyncClient::UpdateInspectVmo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateInspectVmo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Counter::UnownedResultOf::UpdateInspectVmo Counter::Call::UpdateInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::UpdateInspectVmo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Counter::UpdateInspectVmoResponse> Counter::InPlace::UpdateInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(UpdateInspectVmoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<UpdateInspectVmoRequest> params(std::move(_request_buffer));
+ Counter::SetTransactionHeaderFor::UpdateInspectVmoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Counter::UpdateInspectVmoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<UpdateInspectVmoRequest, UpdateInspectVmoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Counter::UpdateInspectVmoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Counter::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kCounter_GetInspectVmo_Ordinal:
+ case kCounter_GetInspectVmo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInspectVmoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInspectVmo(
+ Interface::GetInspectVmoCompleter::Sync(txn));
+ return true;
+ }
+ case kCounter_UpdateInspectVmo_Ordinal:
+ case kCounter_UpdateInspectVmo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UpdateInspectVmoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->UpdateInspectVmo(
+ Interface::UpdateInspectVmoCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Counter::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Counter::Interface::GetInspectVmoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::mem::Buffer buffer) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInspectVmoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetInspectVmoResponse*>(_write_bytes);
+ Counter::SetTransactionHeaderFor::GetInspectVmoResponse(
+ ::fidl::DecodedMessage<GetInspectVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInspectVmoResponse::PrimarySize,
+ GetInspectVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.buffer = std::move(buffer);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInspectVmoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetInspectVmoResponse>(std::move(_response_bytes)));
+}
+
+void Counter::Interface::GetInspectVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::mem::Buffer buffer) {
+ if (_buffer.capacity() < GetInspectVmoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetInspectVmoResponse*>(_buffer.data());
+ Counter::SetTransactionHeaderFor::GetInspectVmoResponse(
+ ::fidl::DecodedMessage<GetInspectVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInspectVmoResponse::PrimarySize,
+ GetInspectVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.buffer = std::move(buffer);
+ _buffer.set_actual(sizeof(GetInspectVmoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetInspectVmoResponse>(std::move(_buffer)));
+}
+
+void Counter::Interface::GetInspectVmoCompleterBase::Reply(::fidl::DecodedMessage<GetInspectVmoResponse> params) {
+ Counter::SetTransactionHeaderFor::GetInspectVmoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UpdateInspectVmoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<UpdateInspectVmoResponse*>(_write_bytes);
+ Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(
+ ::fidl::DecodedMessage<UpdateInspectVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateInspectVmoResponse::PrimarySize,
+ UpdateInspectVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(UpdateInspectVmoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UpdateInspectVmoResponse>(std::move(_response_bytes)));
+}
+
+void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < UpdateInspectVmoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<UpdateInspectVmoResponse*>(_buffer.data());
+ Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(
+ ::fidl::DecodedMessage<UpdateInspectVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ UpdateInspectVmoResponse::PrimarySize,
+ UpdateInspectVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(UpdateInspectVmoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<UpdateInspectVmoResponse>(std::move(_buffer)));
+}
+
+void Counter::Interface::UpdateInspectVmoCompleterBase::Reply(::fidl::DecodedMessage<UpdateInspectVmoResponse> params) {
+ Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Counter::SetTransactionHeaderFor::GetInspectVmoRequest(const ::fidl::DecodedMessage<Counter::GetInspectVmoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_GetInspectVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Counter::SetTransactionHeaderFor::GetInspectVmoResponse(const ::fidl::DecodedMessage<Counter::GetInspectVmoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_GetInspectVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Counter::SetTransactionHeaderFor::UpdateInspectVmoRequest(const ::fidl::DecodedMessage<Counter::UpdateInspectVmoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_UpdateInspectVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Counter::SetTransactionHeaderFor::UpdateInspectVmoResponse(const ::fidl::DecodedMessage<Counter::UpdateInspectVmoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kCounter_UpdateInspectVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+::llcpp::fuchsia::kernel::MemoryStats::Builder MemoryStats::Build() {
+ return MemoryStats::Builder();
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_total_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_free_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_wired_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_total_heap_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_free_heap_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[5 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 5) {
+ max_ordinal_ = 5;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_vmo_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[6 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 6) {
+ max_ordinal_ = 6;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_mmu_overhead_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[7 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 7) {
+ max_ordinal_ = 7;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_ipc_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[8 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 8) {
+ max_ordinal_ = 8;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::kernel::MemoryStats::Builder::set_other_bytes(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[9 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 9) {
+ max_ordinal_ = 9;
+ }
+ return std::move(*this);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kStats_GetMemoryStats_Ordinal = 0x3f74d35b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStats_GetMemoryStats_GenOrdinal = 0x686677932ae41074lu;
+extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetMemoryStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetMemoryStatsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStats_GetCpuStats_Ordinal = 0x34c546a700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStats_GetCpuStats_GenOrdinal = 0x470e2684ca1ca19elu;
+extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetCpuStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetCpuStatsResponseTable;
+
+} // namespace
+template <>
+Stats::ResultOf::GetMemoryStats_Impl<Stats::GetMemoryStatsResponse>::GetMemoryStats_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMemoryStatsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetMemoryStatsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMemoryStatsRequest));
+ ::fidl::DecodedMessage<GetMemoryStatsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Stats::InPlace::GetMemoryStats(std::move(_client_end), Super::response_buffer()));
+}
+
+Stats::ResultOf::GetMemoryStats Stats::SyncClient::GetMemoryStats() {
+ return ResultOf::GetMemoryStats(::zx::unowned_channel(this->channel_));
+}
+
+Stats::ResultOf::GetMemoryStats Stats::Call::GetMemoryStats(::zx::unowned_channel _client_end) {
+ return ResultOf::GetMemoryStats(std::move(_client_end));
+}
+
+template <>
+Stats::UnownedResultOf::GetMemoryStats_Impl<Stats::GetMemoryStatsResponse>::GetMemoryStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetMemoryStatsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetMemoryStatsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetMemoryStatsRequest));
+ ::fidl::DecodedMessage<GetMemoryStatsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Stats::InPlace::GetMemoryStats(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Stats::UnownedResultOf::GetMemoryStats Stats::SyncClient::GetMemoryStats(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMemoryStats(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Stats::UnownedResultOf::GetMemoryStats Stats::Call::GetMemoryStats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMemoryStats(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Stats::GetMemoryStatsResponse> Stats::InPlace::GetMemoryStats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetMemoryStatsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetMemoryStatsRequest> params(std::move(_request_buffer));
+ Stats::SetTransactionHeaderFor::GetMemoryStatsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Stats::GetMemoryStatsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetMemoryStatsRequest, GetMemoryStatsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Stats::GetMemoryStatsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Stats::ResultOf::GetCpuStats_Impl<Stats::GetCpuStatsResponse>::GetCpuStats_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCpuStatsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetCpuStatsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetCpuStatsRequest));
+ ::fidl::DecodedMessage<GetCpuStatsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Stats::InPlace::GetCpuStats(std::move(_client_end), Super::response_buffer()));
+}
+
+Stats::ResultOf::GetCpuStats Stats::SyncClient::GetCpuStats() {
+ return ResultOf::GetCpuStats(::zx::unowned_channel(this->channel_));
+}
+
+Stats::ResultOf::GetCpuStats Stats::Call::GetCpuStats(::zx::unowned_channel _client_end) {
+ return ResultOf::GetCpuStats(std::move(_client_end));
+}
+
+template <>
+Stats::UnownedResultOf::GetCpuStats_Impl<Stats::GetCpuStatsResponse>::GetCpuStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetCpuStatsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetCpuStatsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetCpuStatsRequest));
+ ::fidl::DecodedMessage<GetCpuStatsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Stats::InPlace::GetCpuStats(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Stats::UnownedResultOf::GetCpuStats Stats::SyncClient::GetCpuStats(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCpuStats(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Stats::UnownedResultOf::GetCpuStats Stats::Call::GetCpuStats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetCpuStats(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Stats::GetCpuStatsResponse> Stats::InPlace::GetCpuStats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetCpuStatsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetCpuStatsRequest> params(std::move(_request_buffer));
+ Stats::SetTransactionHeaderFor::GetCpuStatsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Stats::GetCpuStatsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetCpuStatsRequest, GetCpuStatsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Stats::GetCpuStatsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Stats::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kStats_GetMemoryStats_Ordinal:
+ case kStats_GetMemoryStats_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetMemoryStatsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetMemoryStats(
+ Interface::GetMemoryStatsCompleter::Sync(txn));
+ return true;
+ }
+ case kStats_GetCpuStats_Ordinal:
+ case kStats_GetCpuStats_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetCpuStatsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetCpuStats(
+ Interface::GetCpuStatsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Stats::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Stats::Interface::GetMemoryStatsCompleterBase::Reply(::llcpp::fuchsia::kernel::MemoryStats stats) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMemoryStatsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetMemoryStatsResponse _response = {};
+ Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(
+ ::fidl::DecodedMessage<GetMemoryStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMemoryStatsResponse::PrimarySize,
+ GetMemoryStatsResponse::PrimarySize)));
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Stats::Interface::GetMemoryStatsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::kernel::MemoryStats stats) {
+ if (_buffer.capacity() < GetMemoryStatsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetMemoryStatsResponse _response = {};
+ Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(
+ ::fidl::DecodedMessage<GetMemoryStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMemoryStatsResponse::PrimarySize,
+ GetMemoryStatsResponse::PrimarySize)));
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Stats::Interface::GetMemoryStatsCompleterBase::Reply(::fidl::DecodedMessage<GetMemoryStatsResponse> params) {
+ Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Stats::Interface::GetCpuStatsCompleterBase::Reply(::llcpp::fuchsia::kernel::CpuStats stats) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetCpuStatsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetCpuStatsResponse _response = {};
+ Stats::SetTransactionHeaderFor::GetCpuStatsResponse(
+ ::fidl::DecodedMessage<GetCpuStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCpuStatsResponse::PrimarySize,
+ GetCpuStatsResponse::PrimarySize)));
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Stats::Interface::GetCpuStatsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::kernel::CpuStats stats) {
+ if (_buffer.capacity() < GetCpuStatsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetCpuStatsResponse _response = {};
+ Stats::SetTransactionHeaderFor::GetCpuStatsResponse(
+ ::fidl::DecodedMessage<GetCpuStatsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetCpuStatsResponse::PrimarySize,
+ GetCpuStatsResponse::PrimarySize)));
+ _response.stats = std::move(stats);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Stats::Interface::GetCpuStatsCompleterBase::Reply(::fidl::DecodedMessage<GetCpuStatsResponse> params) {
+ Stats::SetTransactionHeaderFor::GetCpuStatsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Stats::SetTransactionHeaderFor::GetMemoryStatsRequest(const ::fidl::DecodedMessage<Stats::GetMemoryStatsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetMemoryStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Stats::SetTransactionHeaderFor::GetMemoryStatsResponse(const ::fidl::DecodedMessage<Stats::GetMemoryStatsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetMemoryStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Stats::SetTransactionHeaderFor::GetCpuStatsRequest(const ::fidl::DecodedMessage<Stats::GetCpuStatsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetCpuStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Stats::SetTransactionHeaderFor::GetCpuStatsResponse(const ::fidl::DecodedMessage<Stats::GetCpuStatsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStats_GetCpuStats_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace kernel
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-kernel/gen/llcpp/include/fuchsia/kernel/llcpp/fidl.h b/zircon/system/fidl/fuchsia-kernel/gen/llcpp/include/fuchsia/kernel/llcpp/fidl.h
new file mode 100644
index 0000000..6bbbf60
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-kernel/gen/llcpp/include/fuchsia/kernel/llcpp/fidl.h
@@ -0,0 +1,1584 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/mem/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace kernel {
+
+struct PerCpuStats;
+struct CpuStats;
+class MexecBroker;
+class DebugBroker;
+class Counter;
+struct MemoryStats;
+class Stats;
+
+extern "C" const fidl_type_t v1_fuchsia_kernel_PerCpuStatsTable;
+
+struct PerCpuStats final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const uint32_t& cpu_number() const {
+ ZX_ASSERT(has_cpu_number());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ uint32_t& cpu_number() {
+ ZX_ASSERT(has_cpu_number());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_cpu_number() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ const uint32_t& flags() const {
+ ZX_ASSERT(has_flags());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ uint32_t& flags() {
+ ZX_ASSERT(has_flags());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_flags() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ const int64_t& idle_time() const {
+ ZX_ASSERT(has_idle_time());
+ return *reinterpret_cast<const int64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ int64_t& idle_time() {
+ ZX_ASSERT(has_idle_time());
+ return *reinterpret_cast<int64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_idle_time() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ const uint64_t& reschedules() const {
+ ZX_ASSERT(has_reschedules());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ uint64_t& reschedules() {
+ ZX_ASSERT(has_reschedules());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_reschedules() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ const uint64_t& context_switches() const {
+ ZX_ASSERT(has_context_switches());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ uint64_t& context_switches() {
+ ZX_ASSERT(has_context_switches());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_context_switches() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ const uint64_t& irq_preempts() const {
+ ZX_ASSERT(has_irq_preempts());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(6 - 1).data);
+ }
+ uint64_t& irq_preempts() {
+ ZX_ASSERT(has_irq_preempts());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(6 - 1).data);
+ }
+ bool has_irq_preempts() const {
+ return EnvelopesView::count() >= 6 && EnvelopesView::at(6 - 1).data != nullptr;
+ }
+
+ const uint64_t& yields() const {
+ ZX_ASSERT(has_yields());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(7 - 1).data);
+ }
+ uint64_t& yields() {
+ ZX_ASSERT(has_yields());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(7 - 1).data);
+ }
+ bool has_yields() const {
+ return EnvelopesView::count() >= 7 && EnvelopesView::at(7 - 1).data != nullptr;
+ }
+
+ const uint64_t& ints() const {
+ ZX_ASSERT(has_ints());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(8 - 1).data);
+ }
+ uint64_t& ints() {
+ ZX_ASSERT(has_ints());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(8 - 1).data);
+ }
+ bool has_ints() const {
+ return EnvelopesView::count() >= 8 && EnvelopesView::at(8 - 1).data != nullptr;
+ }
+
+ const uint64_t& timer_ints() const {
+ ZX_ASSERT(has_timer_ints());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(9 - 1).data);
+ }
+ uint64_t& timer_ints() {
+ ZX_ASSERT(has_timer_ints());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(9 - 1).data);
+ }
+ bool has_timer_ints() const {
+ return EnvelopesView::count() >= 9 && EnvelopesView::at(9 - 1).data != nullptr;
+ }
+
+ const uint64_t& timers() const {
+ ZX_ASSERT(has_timers());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(10 - 1).data);
+ }
+ uint64_t& timers() {
+ ZX_ASSERT(has_timers());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(10 - 1).data);
+ }
+ bool has_timers() const {
+ return EnvelopesView::count() >= 10 && EnvelopesView::at(10 - 1).data != nullptr;
+ }
+
+ const uint64_t& page_faults() const {
+ ZX_ASSERT(has_page_faults());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(11 - 1).data);
+ }
+ uint64_t& page_faults() {
+ ZX_ASSERT(has_page_faults());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(11 - 1).data);
+ }
+ bool has_page_faults() const {
+ return EnvelopesView::count() >= 11 && EnvelopesView::at(11 - 1).data != nullptr;
+ }
+
+ const uint64_t& exceptions() const {
+ ZX_ASSERT(has_exceptions());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(12 - 1).data);
+ }
+ uint64_t& exceptions() {
+ ZX_ASSERT(has_exceptions());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(12 - 1).data);
+ }
+ bool has_exceptions() const {
+ return EnvelopesView::count() >= 12 && EnvelopesView::at(12 - 1).data != nullptr;
+ }
+
+ const uint64_t& syscalls() const {
+ ZX_ASSERT(has_syscalls());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(13 - 1).data);
+ }
+ uint64_t& syscalls() {
+ ZX_ASSERT(has_syscalls());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(13 - 1).data);
+ }
+ bool has_syscalls() const {
+ return EnvelopesView::count() >= 13 && EnvelopesView::at(13 - 1).data != nullptr;
+ }
+
+ const uint64_t& reschedule_ipis() const {
+ ZX_ASSERT(has_reschedule_ipis());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(14 - 1).data);
+ }
+ uint64_t& reschedule_ipis() {
+ ZX_ASSERT(has_reschedule_ipis());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(14 - 1).data);
+ }
+ bool has_reschedule_ipis() const {
+ return EnvelopesView::count() >= 14 && EnvelopesView::at(14 - 1).data != nullptr;
+ }
+
+ const uint64_t& generic_ipis() const {
+ ZX_ASSERT(has_generic_ipis());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(15 - 1).data);
+ }
+ uint64_t& generic_ipis() {
+ ZX_ASSERT(has_generic_ipis());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(15 - 1).data);
+ }
+ bool has_generic_ipis() const {
+ return EnvelopesView::count() >= 15 && EnvelopesView::at(15 - 1).data != nullptr;
+ }
+
+ PerCpuStats() = default;
+ ~PerCpuStats() = default;
+ PerCpuStats(PerCpuStats&& other) noexcept = default;
+ PerCpuStats& operator=(PerCpuStats&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_PerCpuStatsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 360;
+ static constexpr bool HasPointer = true;
+
+ private:
+ PerCpuStats(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class PerCpuStats::Builder {
+ public:
+ PerCpuStats view() { return PerCpuStats(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_cpu_number(uint32_t* elem);
+
+ Builder&& set_flags(uint32_t* elem);
+
+ Builder&& set_idle_time(int64_t* elem);
+
+ Builder&& set_reschedules(uint64_t* elem);
+
+ Builder&& set_context_switches(uint64_t* elem);
+
+ Builder&& set_irq_preempts(uint64_t* elem);
+
+ Builder&& set_yields(uint64_t* elem);
+
+ Builder&& set_ints(uint64_t* elem);
+
+ Builder&& set_timer_ints(uint64_t* elem);
+
+ Builder&& set_timers(uint64_t* elem);
+
+ Builder&& set_page_faults(uint64_t* elem);
+
+ Builder&& set_exceptions(uint64_t* elem);
+
+ Builder&& set_syscalls(uint64_t* elem);
+
+ Builder&& set_reschedule_ipis(uint64_t* elem);
+
+ Builder&& set_generic_ipis(uint64_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder PerCpuStats::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 15> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_kernel_MemoryStatsTable;
+
+struct MemoryStats final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const uint64_t& total_bytes() const {
+ ZX_ASSERT(has_total_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ uint64_t& total_bytes() {
+ ZX_ASSERT(has_total_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_total_bytes() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ const uint64_t& free_bytes() const {
+ ZX_ASSERT(has_free_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ uint64_t& free_bytes() {
+ ZX_ASSERT(has_free_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_free_bytes() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ const uint64_t& wired_bytes() const {
+ ZX_ASSERT(has_wired_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ uint64_t& wired_bytes() {
+ ZX_ASSERT(has_wired_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_wired_bytes() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ const uint64_t& total_heap_bytes() const {
+ ZX_ASSERT(has_total_heap_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ uint64_t& total_heap_bytes() {
+ ZX_ASSERT(has_total_heap_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_total_heap_bytes() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ const uint64_t& free_heap_bytes() const {
+ ZX_ASSERT(has_free_heap_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ uint64_t& free_heap_bytes() {
+ ZX_ASSERT(has_free_heap_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(5 - 1).data);
+ }
+ bool has_free_heap_bytes() const {
+ return EnvelopesView::count() >= 5 && EnvelopesView::at(5 - 1).data != nullptr;
+ }
+
+ const uint64_t& vmo_bytes() const {
+ ZX_ASSERT(has_vmo_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(6 - 1).data);
+ }
+ uint64_t& vmo_bytes() {
+ ZX_ASSERT(has_vmo_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(6 - 1).data);
+ }
+ bool has_vmo_bytes() const {
+ return EnvelopesView::count() >= 6 && EnvelopesView::at(6 - 1).data != nullptr;
+ }
+
+ const uint64_t& mmu_overhead_bytes() const {
+ ZX_ASSERT(has_mmu_overhead_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(7 - 1).data);
+ }
+ uint64_t& mmu_overhead_bytes() {
+ ZX_ASSERT(has_mmu_overhead_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(7 - 1).data);
+ }
+ bool has_mmu_overhead_bytes() const {
+ return EnvelopesView::count() >= 7 && EnvelopesView::at(7 - 1).data != nullptr;
+ }
+
+ const uint64_t& ipc_bytes() const {
+ ZX_ASSERT(has_ipc_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(8 - 1).data);
+ }
+ uint64_t& ipc_bytes() {
+ ZX_ASSERT(has_ipc_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(8 - 1).data);
+ }
+ bool has_ipc_bytes() const {
+ return EnvelopesView::count() >= 8 && EnvelopesView::at(8 - 1).data != nullptr;
+ }
+
+ const uint64_t& other_bytes() const {
+ ZX_ASSERT(has_other_bytes());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(9 - 1).data);
+ }
+ uint64_t& other_bytes() {
+ ZX_ASSERT(has_other_bytes());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(9 - 1).data);
+ }
+ bool has_other_bytes() const {
+ return EnvelopesView::count() >= 9 && EnvelopesView::at(9 - 1).data != nullptr;
+ }
+
+ MemoryStats() = default;
+ ~MemoryStats() = default;
+ MemoryStats(MemoryStats&& other) noexcept = default;
+ MemoryStats& operator=(MemoryStats&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_MemoryStatsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 216;
+ static constexpr bool HasPointer = true;
+
+ private:
+ MemoryStats(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class MemoryStats::Builder {
+ public:
+ MemoryStats view() { return MemoryStats(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_total_bytes(uint64_t* elem);
+
+ Builder&& set_free_bytes(uint64_t* elem);
+
+ Builder&& set_wired_bytes(uint64_t* elem);
+
+ Builder&& set_total_heap_bytes(uint64_t* elem);
+
+ Builder&& set_free_heap_bytes(uint64_t* elem);
+
+ Builder&& set_vmo_bytes(uint64_t* elem);
+
+ Builder&& set_mmu_overhead_bytes(uint64_t* elem);
+
+ Builder&& set_ipc_bytes(uint64_t* elem);
+
+ Builder&& set_other_bytes(uint64_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder MemoryStats::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 9> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_kernel_CpuStatsTable;
+
+struct CpuStats {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_CpuStatsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 192512;
+ static constexpr bool HasPointer = true;
+
+ uint64_t actual_num_cpus = {};
+
+ ::fidl::VectorView<::llcpp::fuchsia::kernel::PerCpuStats> per_cpu_stats = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_kernel_MexecBrokerPerformMexecRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_MexecBrokerPerformMexecResponseTable;
+
+// Acts on behalf of the caller to interact with privileged mexec system call.
+class MexecBroker final {
+ MexecBroker() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.kernel.MexecBroker";
+
+ struct PerformMexecRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo kernel;
+ ::zx::vmo bootdata;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_MexecBrokerPerformMexecRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class PerformMexec_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ PerformMexec_Impl(::zx::unowned_channel _client_end, ::zx::vmo kernel, ::zx::vmo bootdata);
+ ~PerformMexec_Impl() = default;
+ PerformMexec_Impl(PerformMexec_Impl&& other) = default;
+ PerformMexec_Impl& operator=(PerformMexec_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using PerformMexec = PerformMexec_Impl;
+ };
+
+ // 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:
+ class PerformMexec_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ PerformMexec_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata);
+ ~PerformMexec_Impl() = default;
+ PerformMexec_Impl(PerformMexec_Impl&& other) = default;
+ PerformMexec_Impl& operator=(PerformMexec_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using PerformMexec = PerformMexec_Impl;
+ };
+
+ 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_; }
+
+ // Perform an mexec with the given kernel and bootdata.
+ // See ZX-2069 for the thoughts on deprecating mexec.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::PerformMexec PerformMexec(::zx::vmo kernel, ::zx::vmo bootdata);
+
+ // Perform an mexec with the given kernel and bootdata.
+ // See ZX-2069 for the thoughts on deprecating mexec.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::PerformMexec PerformMexec(::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata);
+
+ 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:
+
+ // Perform an mexec with the given kernel and bootdata.
+ // See ZX-2069 for the thoughts on deprecating mexec.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::PerformMexec PerformMexec(::zx::unowned_channel _client_end, ::zx::vmo kernel, ::zx::vmo bootdata);
+
+ // Perform an mexec with the given kernel and bootdata.
+ // See ZX-2069 for the thoughts on deprecating mexec.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::PerformMexec PerformMexec(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo kernel, ::zx::vmo bootdata);
+
+ };
+
+ // 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:
+
+ // Perform an mexec with the given kernel and bootdata.
+ // See ZX-2069 for the thoughts on deprecating mexec.
+ static ::fidl::internal::StatusAndError PerformMexec(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<PerformMexecRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = MexecBroker;
+ using _Base = ::fidl::CompleterBase;
+
+ using PerformMexecCompleter = ::fidl::Completer<>;
+
+ virtual void PerformMexec(::zx::vmo kernel, ::zx::vmo bootdata, PerformMexecCompleter::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 PerformMexecRequest(const ::fidl::DecodedMessage<MexecBroker::PerformMexecRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSendDebugCommandRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSendDebugCommandResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSetTracingEnabledRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_DebugBrokerSetTracingEnabledResponseTable;
+
+// Acts on behalf of the caller to interact with privileged debug system calls.
+class DebugBroker final {
+ DebugBroker() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.kernel.DebugBroker";
+
+ struct SendDebugCommandResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_DebugBrokerSendDebugCommandResponseTable;
+ 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 SendDebugCommandRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView command;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_DebugBrokerSendDebugCommandRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = SendDebugCommandResponse;
+ };
+
+ struct SetTracingEnabledResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_DebugBrokerSetTracingEnabledResponseTable;
+ 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 SetTracingEnabledRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool enabled;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_DebugBrokerSetTracingEnabledRequestTable;
+ 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 = SetTracingEnabledResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class SendDebugCommand_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SendDebugCommand_Impl(::zx::unowned_channel _client_end, ::fidl::StringView command);
+ ~SendDebugCommand_Impl() = default;
+ SendDebugCommand_Impl(SendDebugCommand_Impl&& other) = default;
+ SendDebugCommand_Impl& operator=(SendDebugCommand_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 SetTracingEnabled_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetTracingEnabled_Impl(::zx::unowned_channel _client_end, bool enabled);
+ ~SetTracingEnabled_Impl() = default;
+ SetTracingEnabled_Impl(SetTracingEnabled_Impl&& other) = default;
+ SetTracingEnabled_Impl& operator=(SetTracingEnabled_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 SendDebugCommand = SendDebugCommand_Impl<SendDebugCommandResponse>;
+ using SetTracingEnabled = SetTracingEnabled_Impl<SetTracingEnabledResponse>;
+ };
+
+ // 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 SendDebugCommand_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SendDebugCommand_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer);
+ ~SendDebugCommand_Impl() = default;
+ SendDebugCommand_Impl(SendDebugCommand_Impl&& other) = default;
+ SendDebugCommand_Impl& operator=(SendDebugCommand_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 SetTracingEnabled_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetTracingEnabled_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::fidl::BytePart _response_buffer);
+ ~SetTracingEnabled_Impl() = default;
+ SetTracingEnabled_Impl(SetTracingEnabled_Impl&& other) = default;
+ SetTracingEnabled_Impl& operator=(SetTracingEnabled_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 SendDebugCommand = SendDebugCommand_Impl<SendDebugCommandResponse>;
+ using SetTracingEnabled = SetTracingEnabled_Impl<SetTracingEnabledResponse>;
+ };
+
+ 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_; }
+
+ // Pass debug command through to the kernel shell.
+ // Look at zx_debug_send_command syscall handling to find valid values.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SendDebugCommand SendDebugCommand(::fidl::StringView command);
+
+ // Pass debug command through to the kernel shell.
+ // Look at zx_debug_send_command syscall handling to find valid values.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SendDebugCommand SendDebugCommand(::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer);
+
+ // Sets whether kernel tracing (ktrace) is enabled or disabled.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetTracingEnabled SetTracingEnabled(bool enabled);
+
+ // Sets whether kernel tracing (ktrace) is enabled or disabled.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetTracingEnabled SetTracingEnabled(::fidl::BytePart _request_buffer, bool enabled, ::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:
+
+ // Pass debug command through to the kernel shell.
+ // Look at zx_debug_send_command syscall handling to find valid values.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SendDebugCommand SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::StringView command);
+
+ // Pass debug command through to the kernel shell.
+ // Look at zx_debug_send_command syscall handling to find valid values.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SendDebugCommand SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView command, ::fidl::BytePart _response_buffer);
+
+ // Sets whether kernel tracing (ktrace) is enabled or disabled.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetTracingEnabled SetTracingEnabled(::zx::unowned_channel _client_end, bool enabled);
+
+ // Sets whether kernel tracing (ktrace) is enabled or disabled.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetTracingEnabled SetTracingEnabled(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enabled, ::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:
+
+ // Pass debug command through to the kernel shell.
+ // Look at zx_debug_send_command syscall handling to find valid values.
+ static ::fidl::DecodeResult<SendDebugCommandResponse> SendDebugCommand(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SendDebugCommandRequest> params, ::fidl::BytePart response_buffer);
+
+ // Sets whether kernel tracing (ktrace) is enabled or disabled.
+ static ::fidl::DecodeResult<SetTracingEnabledResponse> SetTracingEnabled(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetTracingEnabledRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DebugBroker;
+ using _Base = ::fidl::CompleterBase;
+
+ class SendDebugCommandCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SendDebugCommandResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SendDebugCommandCompleter = ::fidl::Completer<SendDebugCommandCompleterBase>;
+
+ virtual void SendDebugCommand(::fidl::StringView command, SendDebugCommandCompleter::Sync _completer) = 0;
+
+ class SetTracingEnabledCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetTracingEnabledResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetTracingEnabledCompleter = ::fidl::Completer<SetTracingEnabledCompleterBase>;
+
+ virtual void SetTracingEnabled(bool enabled, SetTracingEnabledCompleter::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 SendDebugCommandRequest(const ::fidl::DecodedMessage<DebugBroker::SendDebugCommandRequest>& _msg);
+ static void SendDebugCommandResponse(const ::fidl::DecodedMessage<DebugBroker::SendDebugCommandResponse>& _msg);
+ static void SetTracingEnabledRequest(const ::fidl::DecodedMessage<DebugBroker::SetTracingEnabledRequest>& _msg);
+ static void SetTracingEnabledResponse(const ::fidl::DecodedMessage<DebugBroker::SetTracingEnabledResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_kernel_CounterGetInspectVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_CounterGetInspectVmoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_CounterUpdateInspectVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_CounterUpdateInspectVmoResponseTable;
+
+// Protocol for retrieving kcounter information.
+class Counter final {
+ Counter() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.kernel.Counter";
+
+ struct GetInspectVmoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::mem::Buffer buffer;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_CounterGetInspectVmoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ 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 GetInspectVmoRequest = ::fidl::AnyZeroArgMessage;
+
+ struct UpdateInspectVmoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_CounterUpdateInspectVmoResponseTable;
+ 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 UpdateInspectVmoRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetInspectVmo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetInspectVmo_Impl(::zx::unowned_channel _client_end);
+ ~GetInspectVmo_Impl() = default;
+ GetInspectVmo_Impl(GetInspectVmo_Impl&& other) = default;
+ GetInspectVmo_Impl& operator=(GetInspectVmo_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 UpdateInspectVmo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ UpdateInspectVmo_Impl(::zx::unowned_channel _client_end);
+ ~UpdateInspectVmo_Impl() = default;
+ UpdateInspectVmo_Impl(UpdateInspectVmo_Impl&& other) = default;
+ UpdateInspectVmo_Impl& operator=(UpdateInspectVmo_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 GetInspectVmo = GetInspectVmo_Impl<GetInspectVmoResponse>;
+ using UpdateInspectVmo = UpdateInspectVmo_Impl<UpdateInspectVmoResponse>;
+ };
+
+ // 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 GetInspectVmo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetInspectVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetInspectVmo_Impl() = default;
+ GetInspectVmo_Impl(GetInspectVmo_Impl&& other) = default;
+ GetInspectVmo_Impl& operator=(GetInspectVmo_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 UpdateInspectVmo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ UpdateInspectVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~UpdateInspectVmo_Impl() = default;
+ UpdateInspectVmo_Impl(UpdateInspectVmo_Impl&& other) = default;
+ UpdateInspectVmo_Impl& operator=(UpdateInspectVmo_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 GetInspectVmo = GetInspectVmo_Impl<GetInspectVmoResponse>;
+ using UpdateInspectVmo = UpdateInspectVmo_Impl<UpdateInspectVmoResponse>;
+ };
+
+ 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_; }
+
+ // Retrives a VMO containining summarized kcounter data. The vmo returned
+ // in |buffer| is in "inspect-vmo" format, documented elsewhere.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetInspectVmo GetInspectVmo();
+
+ // Retrives a VMO containining summarized kcounter data. The vmo returned
+ // in |buffer| is in "inspect-vmo" format, documented elsewhere.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetInspectVmo GetInspectVmo(::fidl::BytePart _response_buffer);
+
+ // Request that the previously-returned VMO buffer's data be updated. The
+ // data may not be updated if it was already recently updated (updates are
+ // limited to an unspecified rate, but approximately every few seconds).
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UpdateInspectVmo UpdateInspectVmo();
+
+ // Request that the previously-returned VMO buffer's data be updated. The
+ // data may not be updated if it was already recently updated (updates are
+ // limited to an unspecified rate, but approximately every few seconds).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UpdateInspectVmo UpdateInspectVmo(::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:
+
+ // Retrives a VMO containining summarized kcounter data. The vmo returned
+ // in |buffer| is in "inspect-vmo" format, documented elsewhere.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetInspectVmo GetInspectVmo(::zx::unowned_channel _client_end);
+
+ // Retrives a VMO containining summarized kcounter data. The vmo returned
+ // in |buffer| is in "inspect-vmo" format, documented elsewhere.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetInspectVmo GetInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Request that the previously-returned VMO buffer's data be updated. The
+ // data may not be updated if it was already recently updated (updates are
+ // limited to an unspecified rate, but approximately every few seconds).
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UpdateInspectVmo UpdateInspectVmo(::zx::unowned_channel _client_end);
+
+ // Request that the previously-returned VMO buffer's data be updated. The
+ // data may not be updated if it was already recently updated (updates are
+ // limited to an unspecified rate, but approximately every few seconds).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UpdateInspectVmo UpdateInspectVmo(::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:
+
+ // Retrives a VMO containining summarized kcounter data. The vmo returned
+ // in |buffer| is in "inspect-vmo" format, documented elsewhere.
+ static ::fidl::DecodeResult<GetInspectVmoResponse> GetInspectVmo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Request that the previously-returned VMO buffer's data be updated. The
+ // data may not be updated if it was already recently updated (updates are
+ // limited to an unspecified rate, but approximately every few seconds).
+ static ::fidl::DecodeResult<UpdateInspectVmoResponse> UpdateInspectVmo(::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 = Counter;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetInspectVmoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::mem::Buffer buffer);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::mem::Buffer buffer);
+ void Reply(::fidl::DecodedMessage<GetInspectVmoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetInspectVmoCompleter = ::fidl::Completer<GetInspectVmoCompleterBase>;
+
+ virtual void GetInspectVmo(GetInspectVmoCompleter::Sync _completer) = 0;
+
+ class UpdateInspectVmoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<UpdateInspectVmoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using UpdateInspectVmoCompleter = ::fidl::Completer<UpdateInspectVmoCompleterBase>;
+
+ virtual void UpdateInspectVmo(UpdateInspectVmoCompleter::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 GetInspectVmoRequest(const ::fidl::DecodedMessage<Counter::GetInspectVmoRequest>& _msg);
+ static void GetInspectVmoResponse(const ::fidl::DecodedMessage<Counter::GetInspectVmoResponse>& _msg);
+ static void UpdateInspectVmoRequest(const ::fidl::DecodedMessage<Counter::UpdateInspectVmoRequest>& _msg);
+ static void UpdateInspectVmoResponse(const ::fidl::DecodedMessage<Counter::UpdateInspectVmoResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetMemoryStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetMemoryStatsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetCpuStatsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_kernel_StatsGetCpuStatsResponseTable;
+
+// Protocol for providing kernel stats. This is roughly a wrapper around zx_object_get_info for
+// the ZX_INFO_KMEM_STATS and ZX_INFO_CPU_STATS topics, which today require the very powerful
+// 'Root Resource' capability to obtain. Instead of vending out that capability, programs that
+// just want stats should use this service instead. If for some reason the protocol fails to
+// retrieve stats, which will be an un-recoverable error, it will close the channel.
+class Stats final {
+ Stats() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.kernel.Stats";
+
+ struct GetMemoryStatsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::kernel::MemoryStats stats;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_StatsGetMemoryStatsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 216;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetMemoryStatsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetCpuStatsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::kernel::CpuStats stats;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_kernel_StatsGetCpuStatsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 192512;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetCpuStatsRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetMemoryStats_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetMemoryStats_Impl(::zx::unowned_channel _client_end);
+ ~GetMemoryStats_Impl() = default;
+ GetMemoryStats_Impl(GetMemoryStats_Impl&& other) = default;
+ GetMemoryStats_Impl& operator=(GetMemoryStats_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 GetCpuStats_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetCpuStats_Impl(::zx::unowned_channel _client_end);
+ ~GetCpuStats_Impl() = default;
+ GetCpuStats_Impl(GetCpuStats_Impl&& other) = default;
+ GetCpuStats_Impl& operator=(GetCpuStats_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 GetMemoryStats = GetMemoryStats_Impl<GetMemoryStatsResponse>;
+ using GetCpuStats = GetCpuStats_Impl<GetCpuStatsResponse>;
+ };
+
+ // 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 GetMemoryStats_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetMemoryStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetMemoryStats_Impl() = default;
+ GetMemoryStats_Impl(GetMemoryStats_Impl&& other) = default;
+ GetMemoryStats_Impl& operator=(GetMemoryStats_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 GetCpuStats_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetCpuStats_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetCpuStats_Impl() = default;
+ GetCpuStats_Impl(GetCpuStats_Impl&& other) = default;
+ GetCpuStats_Impl& operator=(GetCpuStats_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 GetMemoryStats = GetMemoryStats_Impl<GetMemoryStatsResponse>;
+ using GetCpuStats = GetCpuStats_Impl<GetCpuStatsResponse>;
+ };
+
+ 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 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetMemoryStats GetMemoryStats();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetMemoryStats GetMemoryStats(::fidl::BytePart _response_buffer);
+
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetCpuStats GetCpuStats();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetCpuStats GetCpuStats(::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 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetMemoryStats GetMemoryStats(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetMemoryStats GetMemoryStats(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetCpuStats GetCpuStats(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetCpuStats GetCpuStats(::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<GetMemoryStatsResponse> GetMemoryStats(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetCpuStatsResponse> GetCpuStats(::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 = Stats;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetMemoryStatsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::kernel::MemoryStats stats);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::kernel::MemoryStats stats);
+ void Reply(::fidl::DecodedMessage<GetMemoryStatsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetMemoryStatsCompleter = ::fidl::Completer<GetMemoryStatsCompleterBase>;
+
+ virtual void GetMemoryStats(GetMemoryStatsCompleter::Sync _completer) = 0;
+
+ class GetCpuStatsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::kernel::CpuStats stats);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::kernel::CpuStats stats);
+ void Reply(::fidl::DecodedMessage<GetCpuStatsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetCpuStatsCompleter = ::fidl::Completer<GetCpuStatsCompleterBase>;
+
+ virtual void GetCpuStats(GetCpuStatsCompleter::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 GetMemoryStatsRequest(const ::fidl::DecodedMessage<Stats::GetMemoryStatsRequest>& _msg);
+ static void GetMemoryStatsResponse(const ::fidl::DecodedMessage<Stats::GetMemoryStatsResponse>& _msg);
+ static void GetCpuStatsRequest(const ::fidl::DecodedMessage<Stats::GetCpuStatsRequest>& _msg);
+ static void GetCpuStatsResponse(const ::fidl::DecodedMessage<Stats::GetCpuStatsResponse>& _msg);
+ };
+};
+
+// Maximum number of bytes in a command string
+constexpr uint32_t DEBUG_COMMAND_MAX = 1024u;
+
+} // namespace kernel
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::PerCpuStats> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::kernel::PerCpuStats>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::CpuStats> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::kernel::CpuStats>);
+static_assert(offsetof(::llcpp::fuchsia::kernel::CpuStats, actual_num_cpus) == 0);
+static_assert(offsetof(::llcpp::fuchsia::kernel::CpuStats, per_cpu_stats) == 8);
+static_assert(sizeof(::llcpp::fuchsia::kernel::CpuStats) == ::llcpp::fuchsia::kernel::CpuStats::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::MexecBroker::PerformMexecRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::MexecBroker::PerformMexecRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::MexecBroker::PerformMexecRequest)
+ == ::llcpp::fuchsia::kernel::MexecBroker::PerformMexecRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::MexecBroker::PerformMexecRequest, kernel) == 16);
+static_assert(offsetof(::llcpp::fuchsia::kernel::MexecBroker::PerformMexecRequest, bootdata) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandRequest)
+ == ::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandRequest, command) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandResponse)
+ == ::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::DebugBroker::SendDebugCommandResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledRequest)
+ == ::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledRequest, enabled) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledResponse)
+ == ::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::DebugBroker::SetTracingEnabledResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::Counter::GetInspectVmoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::Counter::GetInspectVmoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::Counter::GetInspectVmoResponse)
+ == ::llcpp::fuchsia::kernel::Counter::GetInspectVmoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::Counter::GetInspectVmoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::kernel::Counter::GetInspectVmoResponse, buffer) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::Counter::UpdateInspectVmoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::Counter::UpdateInspectVmoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::Counter::UpdateInspectVmoResponse)
+ == ::llcpp::fuchsia::kernel::Counter::UpdateInspectVmoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::Counter::UpdateInspectVmoResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::MemoryStats> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::kernel::MemoryStats>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::Stats::GetMemoryStatsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::Stats::GetMemoryStatsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::Stats::GetMemoryStatsResponse)
+ == ::llcpp::fuchsia::kernel::Stats::GetMemoryStatsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::Stats::GetMemoryStatsResponse, stats) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::kernel::Stats::GetCpuStatsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::kernel::Stats::GetCpuStatsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::kernel::Stats::GetCpuStatsResponse)
+ == ::llcpp::fuchsia::kernel::Stats::GetCpuStatsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::kernel::Stats::GetCpuStatsResponse, stats) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-ldsvc/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-ldsvc/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..32b46a6
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-ldsvc/gen/llcpp/fidl.cc
@@ -0,0 +1,503 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/ldsvc/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace ldsvc {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLoader_Done_Ordinal = 0x501635da00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoader_Done_GenOrdinal = 0x63ba6b76d3671001lu;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderDoneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoader_LoadObject_Ordinal = 0x18d35e6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoader_LoadObject_GenOrdinal = 0x48c5a151d6df2853lu;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderLoadObjectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderLoadObjectResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoader_Config_Ordinal = 0x1adeb78d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoader_Config_GenOrdinal = 0x6a8a1a1464632841lu;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLoader_Clone_Ordinal = 0x3862fcb900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLoader_Clone_GenOrdinal = 0x57e643a9ab6e4c29lu;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderCloneResponseTable;
+
+} // namespace
+
+Loader::ResultOf::Done_Impl::Done_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DoneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DoneRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DoneRequest));
+ ::fidl::DecodedMessage<DoneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Loader::InPlace::Done(std::move(_client_end)));
+}
+
+Loader::ResultOf::Done Loader::SyncClient::Done() {
+ return ResultOf::Done(::zx::unowned_channel(this->channel_));
+}
+
+Loader::ResultOf::Done Loader::Call::Done(::zx::unowned_channel _client_end) {
+ return ResultOf::Done(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError Loader::InPlace::Done(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(DoneRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DoneRequest> params(std::move(_request_buffer));
+ Loader::SetTransactionHeaderFor::DoneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Loader::ResultOf::LoadObject_Impl<Loader::LoadObjectResponse>::LoadObject_Impl(::zx::unowned_channel _client_end, ::fidl::StringView object_name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LoadObjectRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ LoadObjectRequest _request = {};
+ _request.object_name = std::move(object_name);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LoadObjectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Loader::InPlace::LoadObject(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Loader::ResultOf::LoadObject Loader::SyncClient::LoadObject(::fidl::StringView object_name) {
+ return ResultOf::LoadObject(::zx::unowned_channel(this->channel_), std::move(object_name));
+}
+
+Loader::ResultOf::LoadObject Loader::Call::LoadObject(::zx::unowned_channel _client_end, ::fidl::StringView object_name) {
+ return ResultOf::LoadObject(std::move(_client_end), std::move(object_name));
+}
+
+template <>
+Loader::UnownedResultOf::LoadObject_Impl<Loader::LoadObjectResponse>::LoadObject_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView object_name, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LoadObjectRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LoadObjectResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LoadObjectRequest _request = {};
+ _request.object_name = std::move(object_name);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LoadObjectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Loader::InPlace::LoadObject(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Loader::UnownedResultOf::LoadObject Loader::SyncClient::LoadObject(::fidl::BytePart _request_buffer, ::fidl::StringView object_name, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LoadObject(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(object_name), std::move(_response_buffer));
+}
+
+Loader::UnownedResultOf::LoadObject Loader::Call::LoadObject(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView object_name, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LoadObject(std::move(_client_end), std::move(_request_buffer), std::move(object_name), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Loader::LoadObjectResponse> Loader::InPlace::LoadObject(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LoadObjectRequest> params, ::fidl::BytePart response_buffer) {
+ Loader::SetTransactionHeaderFor::LoadObjectRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Loader::LoadObjectResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LoadObjectRequest, LoadObjectResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Loader::LoadObjectResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Loader::ResultOf::Config_Impl<Loader::ConfigResponse>::Config_Impl(::zx::unowned_channel _client_end, ::fidl::StringView config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ ConfigRequest _request = {};
+ _request.config = std::move(config);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConfigRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Loader::InPlace::Config(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Loader::ResultOf::Config Loader::SyncClient::Config(::fidl::StringView config) {
+ return ResultOf::Config(::zx::unowned_channel(this->channel_), std::move(config));
+}
+
+Loader::ResultOf::Config Loader::Call::Config(::zx::unowned_channel _client_end, ::fidl::StringView config) {
+ return ResultOf::Config(std::move(_client_end), std::move(config));
+}
+
+template <>
+Loader::UnownedResultOf::Config_Impl<Loader::ConfigResponse>::Config_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView config, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConfigRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConfigResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ ConfigRequest _request = {};
+ _request.config = std::move(config);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConfigRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Loader::InPlace::Config(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Loader::UnownedResultOf::Config Loader::SyncClient::Config(::fidl::BytePart _request_buffer, ::fidl::StringView config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Config(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+Loader::UnownedResultOf::Config Loader::Call::Config(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Config(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Loader::ConfigResponse> Loader::InPlace::Config(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigRequest> params, ::fidl::BytePart response_buffer) {
+ Loader::SetTransactionHeaderFor::ConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Loader::ConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConfigRequest, ConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Loader::ConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Loader::ResultOf::Clone_Impl<Loader::CloneResponse>::Clone_Impl(::zx::unowned_channel _client_end, ::zx::channel loader) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.loader = std::move(loader);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Loader::InPlace::Clone(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Loader::ResultOf::Clone Loader::SyncClient::Clone(::zx::channel loader) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(loader));
+}
+
+Loader::ResultOf::Clone Loader::Call::Clone(::zx::unowned_channel _client_end, ::zx::channel loader) {
+ return ResultOf::Clone(std::move(_client_end), std::move(loader));
+}
+
+template <>
+Loader::UnownedResultOf::Clone_Impl<Loader::CloneResponse>::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel loader, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CloneResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.loader = std::move(loader);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Loader::InPlace::Clone(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Loader::UnownedResultOf::Clone Loader::SyncClient::Clone(::fidl::BytePart _request_buffer, ::zx::channel loader, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(loader), std::move(_response_buffer));
+}
+
+Loader::UnownedResultOf::Clone Loader::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel loader, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(loader), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Loader::CloneResponse> Loader::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params, ::fidl::BytePart response_buffer) {
+ Loader::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Loader::CloneResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloneRequest, CloneResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Loader::CloneResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Loader::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kLoader_Done_Ordinal:
+ case kLoader_Done_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DoneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Done(
+ Interface::DoneCompleter::Sync(txn));
+ return true;
+ }
+ case kLoader_LoadObject_Ordinal:
+ case kLoader_LoadObject_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LoadObjectRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LoadObject(std::move(message->object_name),
+ Interface::LoadObjectCompleter::Sync(txn));
+ return true;
+ }
+ case kLoader_Config_Ordinal:
+ case kLoader_Config_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Config(std::move(message->config),
+ Interface::ConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kLoader_Clone_Ordinal:
+ case kLoader_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->loader),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Loader::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Loader::Interface::LoadObjectCompleterBase::Reply(int32_t rv, ::zx::vmo object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LoadObjectResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LoadObjectResponse*>(_write_bytes);
+ Loader::SetTransactionHeaderFor::LoadObjectResponse(
+ ::fidl::DecodedMessage<LoadObjectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LoadObjectResponse::PrimarySize,
+ LoadObjectResponse::PrimarySize)));
+ _response.rv = std::move(rv);
+ _response.object = std::move(object);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LoadObjectResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LoadObjectResponse>(std::move(_response_bytes)));
+}
+
+void Loader::Interface::LoadObjectCompleterBase::Reply(::fidl::BytePart _buffer, int32_t rv, ::zx::vmo object) {
+ if (_buffer.capacity() < LoadObjectResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LoadObjectResponse*>(_buffer.data());
+ Loader::SetTransactionHeaderFor::LoadObjectResponse(
+ ::fidl::DecodedMessage<LoadObjectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LoadObjectResponse::PrimarySize,
+ LoadObjectResponse::PrimarySize)));
+ _response.rv = std::move(rv);
+ _response.object = std::move(object);
+ _buffer.set_actual(sizeof(LoadObjectResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LoadObjectResponse>(std::move(_buffer)));
+}
+
+void Loader::Interface::LoadObjectCompleterBase::Reply(::fidl::DecodedMessage<LoadObjectResponse> params) {
+ Loader::SetTransactionHeaderFor::LoadObjectResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Loader::Interface::ConfigCompleterBase::Reply(int32_t rv) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConfigResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConfigResponse*>(_write_bytes);
+ Loader::SetTransactionHeaderFor::ConfigResponse(
+ ::fidl::DecodedMessage<ConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigResponse::PrimarySize,
+ ConfigResponse::PrimarySize)));
+ _response.rv = std::move(rv);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConfigResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigResponse>(std::move(_response_bytes)));
+}
+
+void Loader::Interface::ConfigCompleterBase::Reply(::fidl::BytePart _buffer, int32_t rv) {
+ if (_buffer.capacity() < ConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConfigResponse*>(_buffer.data());
+ Loader::SetTransactionHeaderFor::ConfigResponse(
+ ::fidl::DecodedMessage<ConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConfigResponse::PrimarySize,
+ ConfigResponse::PrimarySize)));
+ _response.rv = std::move(rv);
+ _buffer.set_actual(sizeof(ConfigResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConfigResponse>(std::move(_buffer)));
+}
+
+void Loader::Interface::ConfigCompleterBase::Reply(::fidl::DecodedMessage<ConfigResponse> params) {
+ Loader::SetTransactionHeaderFor::ConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Loader::Interface::CloneCompleterBase::Reply(int32_t rv) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloneResponse*>(_write_bytes);
+ Loader::SetTransactionHeaderFor::CloneResponse(
+ ::fidl::DecodedMessage<CloneResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloneResponse::PrimarySize,
+ CloneResponse::PrimarySize)));
+ _response.rv = std::move(rv);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloneResponse>(std::move(_response_bytes)));
+}
+
+void Loader::Interface::CloneCompleterBase::Reply(::fidl::BytePart _buffer, int32_t rv) {
+ if (_buffer.capacity() < CloneResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloneResponse*>(_buffer.data());
+ Loader::SetTransactionHeaderFor::CloneResponse(
+ ::fidl::DecodedMessage<CloneResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloneResponse::PrimarySize,
+ CloneResponse::PrimarySize)));
+ _response.rv = std::move(rv);
+ _buffer.set_actual(sizeof(CloneResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloneResponse>(std::move(_buffer)));
+}
+
+void Loader::Interface::CloneCompleterBase::Reply(::fidl::DecodedMessage<CloneResponse> params) {
+ Loader::SetTransactionHeaderFor::CloneResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Loader::SetTransactionHeaderFor::DoneRequest(const ::fidl::DecodedMessage<Loader::DoneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoader_Done_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Loader::SetTransactionHeaderFor::LoadObjectRequest(const ::fidl::DecodedMessage<Loader::LoadObjectRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoader_LoadObject_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Loader::SetTransactionHeaderFor::LoadObjectResponse(const ::fidl::DecodedMessage<Loader::LoadObjectResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoader_LoadObject_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Loader::SetTransactionHeaderFor::ConfigRequest(const ::fidl::DecodedMessage<Loader::ConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoader_Config_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Loader::SetTransactionHeaderFor::ConfigResponse(const ::fidl::DecodedMessage<Loader::ConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoader_Config_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Loader::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<Loader::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoader_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Loader::SetTransactionHeaderFor::CloneResponse(const ::fidl::DecodedMessage<Loader::CloneResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLoader_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace ldsvc
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-ldsvc/gen/llcpp/include/fuchsia/ldsvc/llcpp/fidl.h b/zircon/system/fidl/fuchsia-ldsvc/gen/llcpp/include/fuchsia/ldsvc/llcpp/fidl.h
new file mode 100644
index 0000000..eef4ea1
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-ldsvc/gen/llcpp/include/fuchsia/ldsvc/llcpp/fidl.h
@@ -0,0 +1,516 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace ldsvc {
+
+class Loader;
+
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderDoneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderLoadObjectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderLoadObjectResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_ldsvc_LoaderCloneResponseTable;
+
+class Loader final {
+ Loader() = delete;
+ public:
+
+ using DoneRequest = ::fidl::AnyZeroArgMessage;
+
+ struct LoadObjectResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t rv;
+ ::zx::vmo object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_ldsvc_LoaderLoadObjectResponseTable;
+ 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;
+ };
+ struct LoadObjectRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView object_name;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_ldsvc_LoaderLoadObjectRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = LoadObjectResponse;
+ };
+
+ struct ConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t rv;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_ldsvc_LoaderConfigResponseTable;
+ 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 ConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_ldsvc_LoaderConfigRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 1024;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 1024;
+ 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 = ConfigResponse;
+ };
+
+ struct CloneResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t rv;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_ldsvc_LoaderCloneResponseTable;
+ 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 CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel loader;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_ldsvc_LoaderCloneRequestTable;
+ 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 = CloneResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Done_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Done_Impl(::zx::unowned_channel _client_end);
+ ~Done_Impl() = default;
+ Done_Impl(Done_Impl&& other) = default;
+ Done_Impl& operator=(Done_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class LoadObject_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LoadObject_Impl(::zx::unowned_channel _client_end, ::fidl::StringView object_name);
+ ~LoadObject_Impl() = default;
+ LoadObject_Impl(LoadObject_Impl&& other) = default;
+ LoadObject_Impl& operator=(LoadObject_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 Config_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Config_Impl(::zx::unowned_channel _client_end, ::fidl::StringView config);
+ ~Config_Impl() = default;
+ Config_Impl(Config_Impl&& other) = default;
+ Config_Impl& operator=(Config_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 Clone_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::zx::channel loader);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_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 Done = Done_Impl;
+ using LoadObject = LoadObject_Impl<LoadObjectResponse>;
+ using Config = Config_Impl<ConfigResponse>;
+ using Clone = Clone_Impl<CloneResponse>;
+ };
+
+ // 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:
+ class Done_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Done_Impl(::zx::unowned_channel _client_end);
+ ~Done_Impl() = default;
+ Done_Impl(Done_Impl&& other) = default;
+ Done_Impl& operator=(Done_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class LoadObject_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LoadObject_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView object_name, ::fidl::BytePart _response_buffer);
+ ~LoadObject_Impl() = default;
+ LoadObject_Impl(LoadObject_Impl&& other) = default;
+ LoadObject_Impl& operator=(LoadObject_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 Config_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Config_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView config, ::fidl::BytePart _response_buffer);
+ ~Config_Impl() = default;
+ Config_Impl(Config_Impl&& other) = default;
+ Config_Impl& operator=(Config_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 Clone_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel loader, ::fidl::BytePart _response_buffer);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_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 Done = Done_Impl;
+ using LoadObject = LoadObject_Impl<LoadObjectResponse>;
+ using Config = Config_Impl<ConfigResponse>;
+ using Clone = Clone_Impl<CloneResponse>;
+ };
+
+ 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 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Done Done();
+
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::LoadObject LoadObject(::fidl::StringView object_name);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LoadObject LoadObject(::fidl::BytePart _request_buffer, ::fidl::StringView object_name, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Config Config(::fidl::StringView config);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Config Config(::fidl::BytePart _request_buffer, ::fidl::StringView config, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(::zx::channel loader);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, ::zx::channel loader, ::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 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Done Done(::zx::unowned_channel _client_end);
+
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::LoadObject LoadObject(::zx::unowned_channel _client_end, ::fidl::StringView object_name);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LoadObject LoadObject(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView object_name, ::fidl::BytePart _response_buffer);
+
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Config Config(::zx::unowned_channel _client_end, ::fidl::StringView config);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Config Config(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView config, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, ::zx::channel loader);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel loader, ::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::internal::StatusAndError Done(::zx::unowned_channel _client_end);
+
+ static ::fidl::DecodeResult<LoadObjectResponse> LoadObject(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LoadObjectRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ConfigResponse> Config(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConfigRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<CloneResponse> Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Loader;
+ using _Base = ::fidl::CompleterBase;
+
+ using DoneCompleter = ::fidl::Completer<>;
+
+ virtual void Done(DoneCompleter::Sync _completer) = 0;
+
+ class LoadObjectCompleterBase : public _Base {
+ public:
+ void Reply(int32_t rv, ::zx::vmo object);
+ void Reply(::fidl::BytePart _buffer, int32_t rv, ::zx::vmo object);
+ void Reply(::fidl::DecodedMessage<LoadObjectResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LoadObjectCompleter = ::fidl::Completer<LoadObjectCompleterBase>;
+
+ virtual void LoadObject(::fidl::StringView object_name, LoadObjectCompleter::Sync _completer) = 0;
+
+ class ConfigCompleterBase : public _Base {
+ public:
+ void Reply(int32_t rv);
+ void Reply(::fidl::BytePart _buffer, int32_t rv);
+ void Reply(::fidl::DecodedMessage<ConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConfigCompleter = ::fidl::Completer<ConfigCompleterBase>;
+
+ virtual void Config(::fidl::StringView config, ConfigCompleter::Sync _completer) = 0;
+
+ class CloneCompleterBase : public _Base {
+ public:
+ void Reply(int32_t rv);
+ void Reply(::fidl::BytePart _buffer, int32_t rv);
+ void Reply(::fidl::DecodedMessage<CloneResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloneCompleter = ::fidl::Completer<CloneCompleterBase>;
+
+ virtual void Clone(::zx::channel loader, CloneCompleter::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 DoneRequest(const ::fidl::DecodedMessage<Loader::DoneRequest>& _msg);
+ static void LoadObjectRequest(const ::fidl::DecodedMessage<Loader::LoadObjectRequest>& _msg);
+ static void LoadObjectResponse(const ::fidl::DecodedMessage<Loader::LoadObjectResponse>& _msg);
+ static void ConfigRequest(const ::fidl::DecodedMessage<Loader::ConfigRequest>& _msg);
+ static void ConfigResponse(const ::fidl::DecodedMessage<Loader::ConfigResponse>& _msg);
+ static void CloneRequest(const ::fidl::DecodedMessage<Loader::CloneRequest>& _msg);
+ static void CloneResponse(const ::fidl::DecodedMessage<Loader::CloneResponse>& _msg);
+ };
+};
+
+} // namespace ldsvc
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::ldsvc::Loader::LoadObjectRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::ldsvc::Loader::LoadObjectRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::ldsvc::Loader::LoadObjectRequest)
+ == ::llcpp::fuchsia::ldsvc::Loader::LoadObjectRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::ldsvc::Loader::LoadObjectRequest, object_name) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::ldsvc::Loader::LoadObjectResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::ldsvc::Loader::LoadObjectResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::ldsvc::Loader::LoadObjectResponse)
+ == ::llcpp::fuchsia::ldsvc::Loader::LoadObjectResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::ldsvc::Loader::LoadObjectResponse, rv) == 16);
+static_assert(offsetof(::llcpp::fuchsia::ldsvc::Loader::LoadObjectResponse, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::ldsvc::Loader::ConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::ldsvc::Loader::ConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::ldsvc::Loader::ConfigRequest)
+ == ::llcpp::fuchsia::ldsvc::Loader::ConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::ldsvc::Loader::ConfigRequest, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::ldsvc::Loader::ConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::ldsvc::Loader::ConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::ldsvc::Loader::ConfigResponse)
+ == ::llcpp::fuchsia::ldsvc::Loader::ConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::ldsvc::Loader::ConfigResponse, rv) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::ldsvc::Loader::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::ldsvc::Loader::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::ldsvc::Loader::CloneRequest)
+ == ::llcpp::fuchsia::ldsvc::Loader::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::ldsvc::Loader::CloneRequest, loader) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::ldsvc::Loader::CloneResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::ldsvc::Loader::CloneResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::ldsvc::Loader::CloneResponse)
+ == ::llcpp::fuchsia::ldsvc::Loader::CloneResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::ldsvc::Loader::CloneResponse, rv) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-mem/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-mem/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..7c73124
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-mem/gen/llcpp/fidl.cc
@@ -0,0 +1,29 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/mem/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace mem {
+auto ::llcpp::fuchsia::mem::Data::which() const -> Tag {
+ ZX_ASSERT(!has_invalid_tag());
+ switch (ordinal()) {
+ case Ordinal::kBytes:
+ case Ordinal::kBuffer:
+ return static_cast<Tag>(ordinal());
+ default:
+ return Tag::kUnknown;
+ }
+}
+
+void ::llcpp::fuchsia::mem::Data::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Data) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Data, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Data, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+} // namespace mem
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-mem/gen/llcpp/include/fuchsia/mem/llcpp/fidl.h b/zircon/system/fidl/fuchsia-mem/gen/llcpp/include/fuchsia/mem/llcpp/fidl.h
new file mode 100644
index 0000000..4dd293c
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-mem/gen/llcpp/include/fuchsia/mem/llcpp/fidl.h
@@ -0,0 +1,219 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace mem {
+
+struct Range;
+struct Buffer;
+struct Data;
+
+extern "C" const fidl_type_t v1_fuchsia_mem_DataTable;
+
+// Binary data that might be stored inline or in a VMO.
+//
+// Useful for performance-sensitive protocols that sometimes receive small
+// amounts of binary data (i.e., which is more efficient to provide using
+// `bytes`) but also need to support arbitrary amounts of data (i.e., which
+// need to be provided out-of-line in a `Buffer`).
+struct Data {
+ Data() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kBytes = 1, // 0x1
+ kBuffer = 2, // 0x2
+ kUnknown = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_bytes() const { return ordinal() == Ordinal::kBytes; }
+
+ static Data WithBytes(::fidl::VectorView<uint8_t>* val) {
+ Data result;
+ result.set_bytes(val);
+ return result;
+ }
+
+ // The binary data provided inline in the message.
+ void set_bytes(::fidl::VectorView<uint8_t>* elem) {
+ ordinal_ = Ordinal::kBytes;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // The binary data provided inline in the message.
+ ::fidl::VectorView<uint8_t>& mutable_bytes() {
+ ZX_ASSERT(ordinal() == Ordinal::kBytes);
+ return *static_cast<::fidl::VectorView<uint8_t>*>(envelope_.data);
+ }
+ const ::fidl::VectorView<uint8_t>& bytes() const {
+ ZX_ASSERT(ordinal() == Ordinal::kBytes);
+ return *static_cast<::fidl::VectorView<uint8_t>*>(envelope_.data);
+ }
+
+ bool is_buffer() const { return ordinal() == Ordinal::kBuffer; }
+
+ static Data WithBuffer(::llcpp::fuchsia::mem::Buffer* val) {
+ Data result;
+ result.set_buffer(val);
+ return result;
+ }
+
+ // The binary data provided out-of-line in a `Buffer`.
+ void set_buffer(::llcpp::fuchsia::mem::Buffer* elem) {
+ ordinal_ = Ordinal::kBuffer;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // The binary data provided out-of-line in a `Buffer`.
+ ::llcpp::fuchsia::mem::Buffer& mutable_buffer() {
+ ZX_ASSERT(ordinal() == Ordinal::kBuffer);
+ return *static_cast<::llcpp::fuchsia::mem::Buffer*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::mem::Buffer& buffer() const {
+ ZX_ASSERT(ordinal() == Ordinal::kBuffer);
+ return *static_cast<::llcpp::fuchsia::mem::Buffer*>(envelope_.data);
+ }
+ void* unknownData() const {
+ ZX_ASSERT(which() == Tag::kUnknown);
+ return envelope_.data;
+ }
+ Tag which() const;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_mem_DataTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kBytes = 1, // 0x1
+ kBuffer = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ switch (static_cast<fidl_xunion_tag_t>(ordinal_)) {
+ case 1:
+ case 835814982:
+ return Ordinal::kBytes;
+ case 2:
+ case 1925873109:
+ return Ordinal::kBuffer;
+ }
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_mem_RangeTable;
+
+// A range of bytes within a VMO.
+struct Range {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_mem_RangeTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The vmo that contains the bytes.
+ ::zx::vmo vmo = {};
+
+ // The offset of the first byte within the range relative to the start of
+ // the VMO.
+ //
+ // For example, if `offset` is zero, then the first byte in the range is
+ // the first byte in the VMO.
+ uint64_t offset = {};
+
+ // The number of bytes in the range.
+ //
+ // For example, if the offset is 3 and the size is 2, and the VMO starts
+ // with "abcdefg...", then the range contains "de".
+ //
+ // The sum of the offset and the size must not be greater than the
+ // physical size of the VMO.
+ uint64_t size = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_mem_BufferTable;
+
+// A buffer for data whose size is not necessarily a multiple of the page
+// size.
+//
+// VMO objects have a physical size that is always a multiple of the page
+// size. As such, VMO alone cannot serve as a buffer for arbitrarly sized
+// data. `fuchsia.mem.Buffer` is a standard struct that aggregate the VMO
+// and its size.
+struct Buffer {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_mem_BufferTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The vmo that contains the buffer.
+ ::zx::vmo vmo = {};
+
+ // The number of bytes in the buffer.
+ //
+ // The content of the buffer begin at the start of the VMO and continue
+ // for `size` bytes. To specify a range of bytes that do not start at
+ // the beginning of the VMO, use `Range` rather than buffer.
+ //
+ // This size must not be greater than the physical size of the VMO.
+ uint64_t size = {};
+};
+
+} // namespace mem
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::mem::Range> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::mem::Range>);
+static_assert(offsetof(::llcpp::fuchsia::mem::Range, vmo) == 0);
+static_assert(offsetof(::llcpp::fuchsia::mem::Range, offset) == 8);
+static_assert(offsetof(::llcpp::fuchsia::mem::Range, size) == 16);
+static_assert(sizeof(::llcpp::fuchsia::mem::Range) == ::llcpp::fuchsia::mem::Range::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::mem::Buffer> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::mem::Buffer>);
+static_assert(offsetof(::llcpp::fuchsia::mem::Buffer, vmo) == 0);
+static_assert(offsetof(::llcpp::fuchsia::mem::Buffer, size) == 8);
+static_assert(sizeof(::llcpp::fuchsia::mem::Buffer) == ::llcpp::fuchsia::mem::Buffer::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::mem::Data> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::mem::Data>);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-minfs/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-minfs/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..f967fd2
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-minfs/gen/llcpp/fidl.cc
@@ -0,0 +1,438 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/minfs/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace minfs {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kMinfs_GetMetrics_Ordinal = 0x4e6b106000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMinfs_GetMetrics_GenOrdinal = 0x410bc6db028528f9lu;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsGetMetricsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsGetMetricsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMinfs_ToggleMetrics_Ordinal = 0x51d81eb600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMinfs_ToggleMetrics_GenOrdinal = 0x5c4946fb4ee6e518lu;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsToggleMetricsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsToggleMetricsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kMinfs_GetAllocatedRegions_Ordinal = 0x2d198b2a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kMinfs_GetAllocatedRegions_GenOrdinal = 0x495daecc5d2be4cblu;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsGetAllocatedRegionsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsGetAllocatedRegionsResponseTable;
+
+} // namespace
+template <>
+Minfs::ResultOf::GetMetrics_Impl<Minfs::GetMetricsResponse>::GetMetrics_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetricsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetMetricsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetMetricsRequest));
+ ::fidl::DecodedMessage<GetMetricsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Minfs::InPlace::GetMetrics(std::move(_client_end), Super::response_buffer()));
+}
+
+Minfs::ResultOf::GetMetrics Minfs::SyncClient::GetMetrics() {
+ return ResultOf::GetMetrics(::zx::unowned_channel(this->channel_));
+}
+
+Minfs::ResultOf::GetMetrics Minfs::Call::GetMetrics(::zx::unowned_channel _client_end) {
+ return ResultOf::GetMetrics(std::move(_client_end));
+}
+
+template <>
+Minfs::UnownedResultOf::GetMetrics_Impl<Minfs::GetMetricsResponse>::GetMetrics_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetMetricsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetMetricsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetMetricsRequest));
+ ::fidl::DecodedMessage<GetMetricsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Minfs::InPlace::GetMetrics(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Minfs::UnownedResultOf::GetMetrics Minfs::SyncClient::GetMetrics(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMetrics(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Minfs::UnownedResultOf::GetMetrics Minfs::Call::GetMetrics(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetMetrics(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Minfs::GetMetricsResponse> Minfs::InPlace::GetMetrics(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetMetricsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetMetricsRequest> params(std::move(_request_buffer));
+ Minfs::SetTransactionHeaderFor::GetMetricsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Minfs::GetMetricsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetMetricsRequest, GetMetricsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Minfs::GetMetricsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Minfs::ResultOf::ToggleMetrics_Impl<Minfs::ToggleMetricsResponse>::ToggleMetrics_Impl(::zx::unowned_channel _client_end, bool enable) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ToggleMetricsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ToggleMetricsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ToggleMetricsRequest*>(_write_bytes);
+ _request.enable = std::move(enable);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ToggleMetricsRequest));
+ ::fidl::DecodedMessage<ToggleMetricsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Minfs::InPlace::ToggleMetrics(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Minfs::ResultOf::ToggleMetrics Minfs::SyncClient::ToggleMetrics(bool enable) {
+ return ResultOf::ToggleMetrics(::zx::unowned_channel(this->channel_), std::move(enable));
+}
+
+Minfs::ResultOf::ToggleMetrics Minfs::Call::ToggleMetrics(::zx::unowned_channel _client_end, bool enable) {
+ return ResultOf::ToggleMetrics(std::move(_client_end), std::move(enable));
+}
+
+template <>
+Minfs::UnownedResultOf::ToggleMetrics_Impl<Minfs::ToggleMetricsResponse>::ToggleMetrics_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ToggleMetricsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ToggleMetricsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ToggleMetricsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ToggleMetricsRequest*>(_request_buffer.data());
+ _request.enable = std::move(enable);
+ _request_buffer.set_actual(sizeof(ToggleMetricsRequest));
+ ::fidl::DecodedMessage<ToggleMetricsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Minfs::InPlace::ToggleMetrics(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Minfs::UnownedResultOf::ToggleMetrics Minfs::SyncClient::ToggleMetrics(::fidl::BytePart _request_buffer, bool enable, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ToggleMetrics(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(enable), std::move(_response_buffer));
+}
+
+Minfs::UnownedResultOf::ToggleMetrics Minfs::Call::ToggleMetrics(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ToggleMetrics(std::move(_client_end), std::move(_request_buffer), std::move(enable), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Minfs::ToggleMetricsResponse> Minfs::InPlace::ToggleMetrics(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ToggleMetricsRequest> params, ::fidl::BytePart response_buffer) {
+ Minfs::SetTransactionHeaderFor::ToggleMetricsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Minfs::ToggleMetricsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ToggleMetricsRequest, ToggleMetricsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Minfs::ToggleMetricsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Minfs::ResultOf::GetAllocatedRegions_Impl<Minfs::GetAllocatedRegionsResponse>::GetAllocatedRegions_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAllocatedRegionsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAllocatedRegionsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAllocatedRegionsRequest));
+ ::fidl::DecodedMessage<GetAllocatedRegionsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Minfs::InPlace::GetAllocatedRegions(std::move(_client_end), Super::response_buffer()));
+}
+
+Minfs::ResultOf::GetAllocatedRegions Minfs::SyncClient::GetAllocatedRegions() {
+ return ResultOf::GetAllocatedRegions(::zx::unowned_channel(this->channel_));
+}
+
+Minfs::ResultOf::GetAllocatedRegions Minfs::Call::GetAllocatedRegions(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAllocatedRegions(std::move(_client_end));
+}
+
+template <>
+Minfs::UnownedResultOf::GetAllocatedRegions_Impl<Minfs::GetAllocatedRegionsResponse>::GetAllocatedRegions_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAllocatedRegionsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAllocatedRegionsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAllocatedRegionsRequest));
+ ::fidl::DecodedMessage<GetAllocatedRegionsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Minfs::InPlace::GetAllocatedRegions(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Minfs::UnownedResultOf::GetAllocatedRegions Minfs::SyncClient::GetAllocatedRegions(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAllocatedRegions(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Minfs::UnownedResultOf::GetAllocatedRegions Minfs::Call::GetAllocatedRegions(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAllocatedRegions(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Minfs::GetAllocatedRegionsResponse> Minfs::InPlace::GetAllocatedRegions(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAllocatedRegionsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAllocatedRegionsRequest> params(std::move(_request_buffer));
+ Minfs::SetTransactionHeaderFor::GetAllocatedRegionsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Minfs::GetAllocatedRegionsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAllocatedRegionsRequest, GetAllocatedRegionsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Minfs::GetAllocatedRegionsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Minfs::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kMinfs_GetMetrics_Ordinal:
+ case kMinfs_GetMetrics_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetMetricsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetMetrics(
+ Interface::GetMetricsCompleter::Sync(txn));
+ return true;
+ }
+ case kMinfs_ToggleMetrics_Ordinal:
+ case kMinfs_ToggleMetrics_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ToggleMetricsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ToggleMetrics(std::move(message->enable),
+ Interface::ToggleMetricsCompleter::Sync(txn));
+ return true;
+ }
+ case kMinfs_GetAllocatedRegions_Ordinal:
+ case kMinfs_GetAllocatedRegions_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAllocatedRegionsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAllocatedRegions(
+ Interface::GetAllocatedRegionsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Minfs::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Minfs::Interface::GetMetricsCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::minfs::Metrics* metrics) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetMetricsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetMetricsResponse _response = {};
+ Minfs::SetTransactionHeaderFor::GetMetricsResponse(
+ ::fidl::DecodedMessage<GetMetricsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMetricsResponse::PrimarySize,
+ GetMetricsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.metrics = std::move(metrics);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Minfs::Interface::GetMetricsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::minfs::Metrics* metrics) {
+ if (_buffer.capacity() < GetMetricsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetMetricsResponse _response = {};
+ Minfs::SetTransactionHeaderFor::GetMetricsResponse(
+ ::fidl::DecodedMessage<GetMetricsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetMetricsResponse::PrimarySize,
+ GetMetricsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.metrics = std::move(metrics);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Minfs::Interface::GetMetricsCompleterBase::Reply(::fidl::DecodedMessage<GetMetricsResponse> params) {
+ Minfs::SetTransactionHeaderFor::GetMetricsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Minfs::Interface::ToggleMetricsCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ToggleMetricsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ToggleMetricsResponse*>(_write_bytes);
+ Minfs::SetTransactionHeaderFor::ToggleMetricsResponse(
+ ::fidl::DecodedMessage<ToggleMetricsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ToggleMetricsResponse::PrimarySize,
+ ToggleMetricsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ToggleMetricsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ToggleMetricsResponse>(std::move(_response_bytes)));
+}
+
+void Minfs::Interface::ToggleMetricsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < ToggleMetricsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ToggleMetricsResponse*>(_buffer.data());
+ Minfs::SetTransactionHeaderFor::ToggleMetricsResponse(
+ ::fidl::DecodedMessage<ToggleMetricsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ToggleMetricsResponse::PrimarySize,
+ ToggleMetricsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(ToggleMetricsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ToggleMetricsResponse>(std::move(_buffer)));
+}
+
+void Minfs::Interface::ToggleMetricsCompleterBase::Reply(::fidl::DecodedMessage<ToggleMetricsResponse> params) {
+ Minfs::SetTransactionHeaderFor::ToggleMetricsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Minfs::Interface::GetAllocatedRegionsCompleterBase::Reply(int32_t status, ::zx::vmo regions, uint64_t count) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAllocatedRegionsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAllocatedRegionsResponse*>(_write_bytes);
+ Minfs::SetTransactionHeaderFor::GetAllocatedRegionsResponse(
+ ::fidl::DecodedMessage<GetAllocatedRegionsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAllocatedRegionsResponse::PrimarySize,
+ GetAllocatedRegionsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.regions = std::move(regions);
+ _response.count = std::move(count);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAllocatedRegionsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAllocatedRegionsResponse>(std::move(_response_bytes)));
+}
+
+void Minfs::Interface::GetAllocatedRegionsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::vmo regions, uint64_t count) {
+ if (_buffer.capacity() < GetAllocatedRegionsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAllocatedRegionsResponse*>(_buffer.data());
+ Minfs::SetTransactionHeaderFor::GetAllocatedRegionsResponse(
+ ::fidl::DecodedMessage<GetAllocatedRegionsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAllocatedRegionsResponse::PrimarySize,
+ GetAllocatedRegionsResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.regions = std::move(regions);
+ _response.count = std::move(count);
+ _buffer.set_actual(sizeof(GetAllocatedRegionsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAllocatedRegionsResponse>(std::move(_buffer)));
+}
+
+void Minfs::Interface::GetAllocatedRegionsCompleterBase::Reply(::fidl::DecodedMessage<GetAllocatedRegionsResponse> params) {
+ Minfs::SetTransactionHeaderFor::GetAllocatedRegionsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Minfs::SetTransactionHeaderFor::GetMetricsRequest(const ::fidl::DecodedMessage<Minfs::GetMetricsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMinfs_GetMetrics_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Minfs::SetTransactionHeaderFor::GetMetricsResponse(const ::fidl::DecodedMessage<Minfs::GetMetricsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMinfs_GetMetrics_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Minfs::SetTransactionHeaderFor::ToggleMetricsRequest(const ::fidl::DecodedMessage<Minfs::ToggleMetricsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMinfs_ToggleMetrics_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Minfs::SetTransactionHeaderFor::ToggleMetricsResponse(const ::fidl::DecodedMessage<Minfs::ToggleMetricsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMinfs_ToggleMetrics_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Minfs::SetTransactionHeaderFor::GetAllocatedRegionsRequest(const ::fidl::DecodedMessage<Minfs::GetAllocatedRegionsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMinfs_GetAllocatedRegions_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Minfs::SetTransactionHeaderFor::GetAllocatedRegionsResponse(const ::fidl::DecodedMessage<Minfs::GetAllocatedRegionsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kMinfs_GetAllocatedRegions_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace minfs
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-minfs/gen/llcpp/include/fuchsia/minfs/llcpp/fidl.h b/zircon/system/fidl/fuchsia-minfs/gen/llcpp/include/fuchsia/minfs/llcpp/fidl.h
new file mode 100644
index 0000000..a8d5ff0
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-minfs/gen/llcpp/include/fuchsia/minfs/llcpp/fidl.h
@@ -0,0 +1,493 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/storage/metrics/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace minfs {
+
+struct Metrics;
+class Minfs;
+struct BlockRegion;
+
+extern "C" const fidl_type_t v1_fuchsia_minfs_MetricsTable;
+
+struct Metrics {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_minfs_MetricsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 688;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::storage::metrics::FsMetrics fs_metrics = {};
+
+ uint64_t initialized_vmos = {};
+
+ uint32_t init_dnum_count = {};
+
+ uint32_t init_inum_count = {};
+
+ uint32_t init_dinum_count = {};
+
+ uint64_t init_user_data_size = {};
+
+ uint64_t init_user_data_ticks = {};
+
+ uint64_t vnodes_opened_cache_hit = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsGetMetricsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsGetMetricsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsToggleMetricsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsToggleMetricsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsGetAllocatedRegionsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_minfs_MinfsGetAllocatedRegionsResponseTable;
+
+class Minfs final {
+ Minfs() = delete;
+ public:
+
+ struct GetMetricsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::minfs::Metrics* metrics;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_minfs_MinfsGetMetricsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 688;
+ 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 GetMetricsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct ToggleMetricsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_minfs_MinfsToggleMetricsResponseTable;
+ 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 ToggleMetricsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool enable;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_minfs_MinfsToggleMetricsRequestTable;
+ 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 = ToggleMetricsResponse;
+ };
+
+ struct GetAllocatedRegionsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::vmo regions;
+ uint64_t count;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_minfs_MinfsGetAllocatedRegionsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 GetAllocatedRegionsRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetMetrics_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetMetrics_Impl(::zx::unowned_channel _client_end);
+ ~GetMetrics_Impl() = default;
+ GetMetrics_Impl(GetMetrics_Impl&& other) = default;
+ GetMetrics_Impl& operator=(GetMetrics_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 ToggleMetrics_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ToggleMetrics_Impl(::zx::unowned_channel _client_end, bool enable);
+ ~ToggleMetrics_Impl() = default;
+ ToggleMetrics_Impl(ToggleMetrics_Impl&& other) = default;
+ ToggleMetrics_Impl& operator=(ToggleMetrics_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 GetAllocatedRegions_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAllocatedRegions_Impl(::zx::unowned_channel _client_end);
+ ~GetAllocatedRegions_Impl() = default;
+ GetAllocatedRegions_Impl(GetAllocatedRegions_Impl&& other) = default;
+ GetAllocatedRegions_Impl& operator=(GetAllocatedRegions_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 GetMetrics = GetMetrics_Impl<GetMetricsResponse>;
+ using ToggleMetrics = ToggleMetrics_Impl<ToggleMetricsResponse>;
+ using GetAllocatedRegions = GetAllocatedRegions_Impl<GetAllocatedRegionsResponse>;
+ };
+
+ // 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 GetMetrics_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetMetrics_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetMetrics_Impl() = default;
+ GetMetrics_Impl(GetMetrics_Impl&& other) = default;
+ GetMetrics_Impl& operator=(GetMetrics_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 ToggleMetrics_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ToggleMetrics_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::fidl::BytePart _response_buffer);
+ ~ToggleMetrics_Impl() = default;
+ ToggleMetrics_Impl(ToggleMetrics_Impl&& other) = default;
+ ToggleMetrics_Impl& operator=(ToggleMetrics_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 GetAllocatedRegions_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAllocatedRegions_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAllocatedRegions_Impl() = default;
+ GetAllocatedRegions_Impl(GetAllocatedRegions_Impl&& other) = default;
+ GetAllocatedRegions_Impl& operator=(GetAllocatedRegions_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 GetMetrics = GetMetrics_Impl<GetMetricsResponse>;
+ using ToggleMetrics = ToggleMetrics_Impl<ToggleMetricsResponse>;
+ using GetAllocatedRegions = GetAllocatedRegions_Impl<GetAllocatedRegionsResponse>;
+ };
+
+ 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 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetMetrics GetMetrics();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetMetrics GetMetrics(::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ToggleMetrics ToggleMetrics(bool enable);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ToggleMetrics ToggleMetrics(::fidl::BytePart _request_buffer, bool enable, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAllocatedRegions GetAllocatedRegions();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAllocatedRegions GetAllocatedRegions(::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 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetMetrics GetMetrics(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetMetrics GetMetrics(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ToggleMetrics ToggleMetrics(::zx::unowned_channel _client_end, bool enable);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ToggleMetrics ToggleMetrics(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool enable, ::fidl::BytePart _response_buffer);
+
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAllocatedRegions GetAllocatedRegions(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAllocatedRegions GetAllocatedRegions(::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<GetMetricsResponse> GetMetrics(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<ToggleMetricsResponse> ToggleMetrics(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ToggleMetricsRequest> params, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetAllocatedRegionsResponse> GetAllocatedRegions(::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 = Minfs;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetMetricsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::minfs::Metrics* metrics);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::minfs::Metrics* metrics);
+ void Reply(::fidl::DecodedMessage<GetMetricsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetMetricsCompleter = ::fidl::Completer<GetMetricsCompleterBase>;
+
+ virtual void GetMetrics(GetMetricsCompleter::Sync _completer) = 0;
+
+ class ToggleMetricsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<ToggleMetricsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ToggleMetricsCompleter = ::fidl::Completer<ToggleMetricsCompleterBase>;
+
+ virtual void ToggleMetrics(bool enable, ToggleMetricsCompleter::Sync _completer) = 0;
+
+ class GetAllocatedRegionsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::vmo regions, uint64_t count);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::vmo regions, uint64_t count);
+ void Reply(::fidl::DecodedMessage<GetAllocatedRegionsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAllocatedRegionsCompleter = ::fidl::Completer<GetAllocatedRegionsCompleterBase>;
+
+ virtual void GetAllocatedRegions(GetAllocatedRegionsCompleter::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 GetMetricsRequest(const ::fidl::DecodedMessage<Minfs::GetMetricsRequest>& _msg);
+ static void GetMetricsResponse(const ::fidl::DecodedMessage<Minfs::GetMetricsResponse>& _msg);
+ static void ToggleMetricsRequest(const ::fidl::DecodedMessage<Minfs::ToggleMetricsRequest>& _msg);
+ static void ToggleMetricsResponse(const ::fidl::DecodedMessage<Minfs::ToggleMetricsResponse>& _msg);
+ static void GetAllocatedRegionsRequest(const ::fidl::DecodedMessage<Minfs::GetAllocatedRegionsRequest>& _msg);
+ static void GetAllocatedRegionsResponse(const ::fidl::DecodedMessage<Minfs::GetAllocatedRegionsResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_minfs_BlockRegionTable;
+
+struct BlockRegion {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_minfs_BlockRegionTable;
+ 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;
+
+ uint64_t offset = {};
+
+ uint64_t length = {};
+};
+
+} // namespace minfs
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::minfs::Metrics> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::minfs::Metrics>);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Metrics, fs_metrics) == 0);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Metrics, initialized_vmos) == 640);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Metrics, init_dnum_count) == 648);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Metrics, init_inum_count) == 652);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Metrics, init_dinum_count) == 656);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Metrics, init_user_data_size) == 664);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Metrics, init_user_data_ticks) == 672);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Metrics, vnodes_opened_cache_hit) == 680);
+static_assert(sizeof(::llcpp::fuchsia::minfs::Metrics) == ::llcpp::fuchsia::minfs::Metrics::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::minfs::Minfs::GetMetricsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::minfs::Minfs::GetMetricsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::minfs::Minfs::GetMetricsResponse)
+ == ::llcpp::fuchsia::minfs::Minfs::GetMetricsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Minfs::GetMetricsResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Minfs::GetMetricsResponse, metrics) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::minfs::Minfs::ToggleMetricsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::minfs::Minfs::ToggleMetricsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::minfs::Minfs::ToggleMetricsRequest)
+ == ::llcpp::fuchsia::minfs::Minfs::ToggleMetricsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Minfs::ToggleMetricsRequest, enable) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::minfs::Minfs::ToggleMetricsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::minfs::Minfs::ToggleMetricsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::minfs::Minfs::ToggleMetricsResponse)
+ == ::llcpp::fuchsia::minfs::Minfs::ToggleMetricsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Minfs::ToggleMetricsResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::minfs::Minfs::GetAllocatedRegionsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::minfs::Minfs::GetAllocatedRegionsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::minfs::Minfs::GetAllocatedRegionsResponse)
+ == ::llcpp::fuchsia::minfs::Minfs::GetAllocatedRegionsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Minfs::GetAllocatedRegionsResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Minfs::GetAllocatedRegionsResponse, regions) == 20);
+static_assert(offsetof(::llcpp::fuchsia::minfs::Minfs::GetAllocatedRegionsResponse, count) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::minfs::BlockRegion> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::minfs::BlockRegion>);
+static_assert(offsetof(::llcpp::fuchsia::minfs::BlockRegion, offset) == 0);
+static_assert(offsetof(::llcpp::fuchsia::minfs::BlockRegion, length) == 8);
+static_assert(sizeof(::llcpp::fuchsia::minfs::BlockRegion) == ::llcpp::fuchsia::minfs::BlockRegion::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-net/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-net/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..51fde50
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-net/gen/llcpp/fidl.cc
@@ -0,0 +1,537 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/net/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace net {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kConnectivity_OnNetworkReachable_Ordinal = 0x658708c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kConnectivity_OnNetworkReachable_GenOrdinal = 0x6f099dcaa3ff5b7lu;
+extern "C" const fidl_type_t v1_fuchsia_net_ConnectivityOnNetworkReachableRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_net_ConnectivityOnNetworkReachableEventTable;
+
+} // namespace
+zx_status_t Connectivity::SyncClient::HandleEvents(Connectivity::EventHandlers handlers) {
+ return Connectivity::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Connectivity::Call::HandleEvents(::zx::unowned_channel client_end, Connectivity::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnNetworkReachableResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnNetworkReachableResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnNetworkReachableResponse::MaxNumHandles >= x) {
+ x = OnNetworkReachableResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kConnectivity_OnNetworkReachable_Ordinal:
+ case kConnectivity_OnNetworkReachable_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnNetworkReachableResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_network_reachable(std::move(message->reachable));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Connectivity::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Connectivity::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+zx_status_t Connectivity::SendOnNetworkReachableEvent(::zx::unowned_channel _chan, bool reachable) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnNetworkReachableResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<OnNetworkReachableResponse*>(_write_bytes);
+ Connectivity::SetTransactionHeaderFor::OnNetworkReachableResponse(
+ ::fidl::DecodedMessage<OnNetworkReachableResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnNetworkReachableResponse::PrimarySize,
+ OnNetworkReachableResponse::PrimarySize)));
+ _response.reachable = std::move(reachable);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnNetworkReachableResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<OnNetworkReachableResponse>(std::move(_response_bytes)));
+}
+
+zx_status_t Connectivity::SendOnNetworkReachableEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, bool reachable) {
+ if (_buffer.capacity() < OnNetworkReachableResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ auto& _response = *reinterpret_cast<OnNetworkReachableResponse*>(_buffer.data());
+ Connectivity::SetTransactionHeaderFor::OnNetworkReachableResponse(
+ ::fidl::DecodedMessage<OnNetworkReachableResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnNetworkReachableResponse::PrimarySize,
+ OnNetworkReachableResponse::PrimarySize)));
+ _response.reachable = std::move(reachable);
+ _buffer.set_actual(sizeof(OnNetworkReachableResponse));
+ return ::fidl::Write(::zx::unowned_channel(_chan), ::fidl::DecodedMessage<OnNetworkReachableResponse>(std::move(_buffer)));
+}
+
+zx_status_t Connectivity::SendOnNetworkReachableEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnNetworkReachableResponse> params) {
+ Connectivity::SetTransactionHeaderFor::OnNetworkReachableResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+
+void Connectivity::SetTransactionHeaderFor::OnNetworkReachableResponse(const ::fidl::DecodedMessage<Connectivity::OnNetworkReachableResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kConnectivity_OnNetworkReachable_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::net::NameLookup_LookupHostname_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(NameLookup_LookupHostname_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(NameLookup_LookupHostname_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(NameLookup_LookupHostname_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::net::NameLookup_LookupIp_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(NameLookup_LookupIp_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(NameLookup_LookupIp_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(NameLookup_LookupIp_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::net::IpAddress::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(IpAddress) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(IpAddress, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(IpAddress, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kNameLookup_LookupIp_Ordinal = 0x30c22b4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNameLookup_LookupIp_GenOrdinal = 0x58576c7210cd0f32lu;
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookupLookupIpRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookupLookupIpResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kNameLookup_LookupHostname_Ordinal = 0x17582c9400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kNameLookup_LookupHostname_GenOrdinal = 0x5dfea9b2c92f510alu;
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookupLookupHostnameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookupLookupHostnameResponseTable;
+
+} // namespace
+template <>
+NameLookup::ResultOf::LookupIp_Impl<NameLookup::LookupIpResponse>::LookupIp_Impl(::zx::unowned_channel _client_end, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LookupIpRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LookupIpRequest _request = {};
+ _request.hostname = std::move(hostname);
+ _request.options = std::move(options);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LookupIpRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ NameLookup::InPlace::LookupIp(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+NameLookup::ResultOf::LookupIp NameLookup::SyncClient::LookupIp(::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options) {
+ return ResultOf::LookupIp(::zx::unowned_channel(this->channel_), std::move(hostname), std::move(options));
+}
+
+NameLookup::ResultOf::LookupIp NameLookup::Call::LookupIp(::zx::unowned_channel _client_end, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options) {
+ return ResultOf::LookupIp(std::move(_client_end), std::move(hostname), std::move(options));
+}
+
+template <>
+NameLookup::UnownedResultOf::LookupIp_Impl<NameLookup::LookupIpResponse>::LookupIp_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LookupIpRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LookupIpResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LookupIpRequest _request = {};
+ _request.hostname = std::move(hostname);
+ _request.options = std::move(options);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LookupIpRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ NameLookup::InPlace::LookupIp(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+NameLookup::UnownedResultOf::LookupIp NameLookup::SyncClient::LookupIp(::fidl::BytePart _request_buffer, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LookupIp(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(hostname), std::move(options), std::move(_response_buffer));
+}
+
+NameLookup::UnownedResultOf::LookupIp NameLookup::Call::LookupIp(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LookupIp(std::move(_client_end), std::move(_request_buffer), std::move(hostname), std::move(options), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<NameLookup::LookupIpResponse> NameLookup::InPlace::LookupIp(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LookupIpRequest> params, ::fidl::BytePart response_buffer) {
+ NameLookup::SetTransactionHeaderFor::LookupIpRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NameLookup::LookupIpResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LookupIpRequest, LookupIpResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NameLookup::LookupIpResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+NameLookup::ResultOf::LookupHostname_Impl<NameLookup::LookupHostnameResponse>::LookupHostname_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::IpAddress addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LookupHostnameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LookupHostnameRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LookupHostnameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ NameLookup::InPlace::LookupHostname(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+NameLookup::ResultOf::LookupHostname NameLookup::SyncClient::LookupHostname(::llcpp::fuchsia::net::IpAddress addr) {
+ return ResultOf::LookupHostname(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+NameLookup::ResultOf::LookupHostname NameLookup::Call::LookupHostname(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::IpAddress addr) {
+ return ResultOf::LookupHostname(std::move(_client_end), std::move(addr));
+}
+
+template <>
+NameLookup::UnownedResultOf::LookupHostname_Impl<NameLookup::LookupHostnameResponse>::LookupHostname_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::IpAddress addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LookupHostnameRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LookupHostnameResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LookupHostnameRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LookupHostnameRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ NameLookup::InPlace::LookupHostname(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+NameLookup::UnownedResultOf::LookupHostname NameLookup::SyncClient::LookupHostname(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::IpAddress addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LookupHostname(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+NameLookup::UnownedResultOf::LookupHostname NameLookup::Call::LookupHostname(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::IpAddress addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::LookupHostname(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<NameLookup::LookupHostnameResponse> NameLookup::InPlace::LookupHostname(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LookupHostnameRequest> params, ::fidl::BytePart response_buffer) {
+ NameLookup::SetTransactionHeaderFor::LookupHostnameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NameLookup::LookupHostnameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LookupHostnameRequest, LookupHostnameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<NameLookup::LookupHostnameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool NameLookup::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kNameLookup_LookupIp_Ordinal:
+ case kNameLookup_LookupIp_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LookupIpRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LookupIp(std::move(message->hostname), std::move(message->options),
+ Interface::LookupIpCompleter::Sync(txn));
+ return true;
+ }
+ case kNameLookup_LookupHostname_Ordinal:
+ case kNameLookup_LookupHostname_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LookupHostnameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->LookupHostname(std::move(message->addr),
+ Interface::LookupHostnameCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool NameLookup::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void NameLookup::Interface::LookupIpCompleterBase::Reply(::llcpp::fuchsia::net::NameLookup_LookupIp_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LookupIpResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ LookupIpResponse _response = {};
+ NameLookup::SetTransactionHeaderFor::LookupIpResponse(
+ ::fidl::DecodedMessage<LookupIpResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LookupIpResponse::PrimarySize,
+ LookupIpResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NameLookup::Interface::LookupIpCompleterBase::ReplySuccess(::llcpp::fuchsia::net::IpAddressInfo addr) {
+ NameLookup_LookupIp_Response response;
+ response.addr = std::move(addr);
+
+ Reply(NameLookup_LookupIp_Result::WithResponse(&response));
+}
+void NameLookup::Interface::LookupIpCompleterBase::ReplyError(LookupError error) {
+ Reply(NameLookup_LookupIp_Result::WithErr(&error));
+}
+
+void NameLookup::Interface::LookupIpCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::net::NameLookup_LookupIp_Result result) {
+ if (_buffer.capacity() < LookupIpResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ LookupIpResponse _response = {};
+ NameLookup::SetTransactionHeaderFor::LookupIpResponse(
+ ::fidl::DecodedMessage<LookupIpResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LookupIpResponse::PrimarySize,
+ LookupIpResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NameLookup::Interface::LookupIpCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::net::IpAddressInfo addr) {
+ NameLookup_LookupIp_Response response;
+ response.addr = std::move(addr);
+
+ Reply(std::move(_buffer), NameLookup_LookupIp_Result::WithResponse(&response));
+}
+
+void NameLookup::Interface::LookupIpCompleterBase::Reply(::fidl::DecodedMessage<LookupIpResponse> params) {
+ NameLookup::SetTransactionHeaderFor::LookupIpResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void NameLookup::Interface::LookupHostnameCompleterBase::Reply(::llcpp::fuchsia::net::NameLookup_LookupHostname_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LookupHostnameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ LookupHostnameResponse _response = {};
+ NameLookup::SetTransactionHeaderFor::LookupHostnameResponse(
+ ::fidl::DecodedMessage<LookupHostnameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LookupHostnameResponse::PrimarySize,
+ LookupHostnameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NameLookup::Interface::LookupHostnameCompleterBase::ReplySuccess(::fidl::StringView hostname) {
+ NameLookup_LookupHostname_Response response;
+ response.hostname = std::move(hostname);
+
+ Reply(NameLookup_LookupHostname_Result::WithResponse(&response));
+}
+void NameLookup::Interface::LookupHostnameCompleterBase::ReplyError(LookupError error) {
+ Reply(NameLookup_LookupHostname_Result::WithErr(&error));
+}
+
+void NameLookup::Interface::LookupHostnameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::net::NameLookup_LookupHostname_Result result) {
+ if (_buffer.capacity() < LookupHostnameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ LookupHostnameResponse _response = {};
+ NameLookup::SetTransactionHeaderFor::LookupHostnameResponse(
+ ::fidl::DecodedMessage<LookupHostnameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LookupHostnameResponse::PrimarySize,
+ LookupHostnameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void NameLookup::Interface::LookupHostnameCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView hostname) {
+ NameLookup_LookupHostname_Response response;
+ response.hostname = std::move(hostname);
+
+ Reply(std::move(_buffer), NameLookup_LookupHostname_Result::WithResponse(&response));
+}
+
+void NameLookup::Interface::LookupHostnameCompleterBase::Reply(::fidl::DecodedMessage<LookupHostnameResponse> params) {
+ NameLookup::SetTransactionHeaderFor::LookupHostnameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void NameLookup::SetTransactionHeaderFor::LookupIpRequest(const ::fidl::DecodedMessage<NameLookup::LookupIpRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNameLookup_LookupIp_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void NameLookup::SetTransactionHeaderFor::LookupIpResponse(const ::fidl::DecodedMessage<NameLookup::LookupIpResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNameLookup_LookupIp_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void NameLookup::SetTransactionHeaderFor::LookupHostnameRequest(const ::fidl::DecodedMessage<NameLookup::LookupHostnameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNameLookup_LookupHostname_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void NameLookup::SetTransactionHeaderFor::LookupHostnameResponse(const ::fidl::DecodedMessage<NameLookup::LookupHostnameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kNameLookup_LookupHostname_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace net
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-net/gen/llcpp/include/fuchsia/net/llcpp/fidl.h b/zircon/system/fidl/fuchsia-net/gen/llcpp/include/fuchsia/net/llcpp/fidl.h
new file mode 100644
index 0000000..d46521f
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-net/gen/llcpp/include/fuchsia/net/llcpp/fidl.h
@@ -0,0 +1,1077 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace net {
+
+class Connectivity;
+struct NameLookup_LookupHostname_Response;
+struct MacAddress;
+class LookupIpOptions final {
+public:
+ constexpr LookupIpOptions() : value_(0u) {}
+ explicit constexpr LookupIpOptions(uint8_t value) : value_(value) {}
+ const static LookupIpOptions V4_ADDRS;
+ const static LookupIpOptions V6_ADDRS;
+ const static LookupIpOptions CNAME_LOOKUP;
+ const static LookupIpOptions mask;
+
+ explicit constexpr inline operator uint8_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const LookupIpOptions& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const LookupIpOptions& other) const { return value_ != other.value_; }
+ constexpr inline LookupIpOptions operator~() const;
+ constexpr inline LookupIpOptions operator|(const LookupIpOptions& other) const;
+ constexpr inline LookupIpOptions operator&(const LookupIpOptions& other) const;
+ constexpr inline LookupIpOptions operator^(const LookupIpOptions& other) const;
+ constexpr inline void operator|=(const LookupIpOptions& other);
+ constexpr inline void operator&=(const LookupIpOptions& other);
+ constexpr inline void operator^=(const LookupIpOptions& other);
+
+private:
+ uint8_t value_;
+};
+constexpr const ::llcpp::fuchsia::net::LookupIpOptions LookupIpOptions::V4_ADDRS = ::llcpp::fuchsia::net::LookupIpOptions(1u);
+constexpr const ::llcpp::fuchsia::net::LookupIpOptions LookupIpOptions::V6_ADDRS = ::llcpp::fuchsia::net::LookupIpOptions(2u);
+constexpr const ::llcpp::fuchsia::net::LookupIpOptions LookupIpOptions::CNAME_LOOKUP = ::llcpp::fuchsia::net::LookupIpOptions(4u);
+constexpr const ::llcpp::fuchsia::net::LookupIpOptions LookupIpOptions::mask = ::llcpp::fuchsia::net::LookupIpOptions(7u);
+
+constexpr inline ::llcpp::fuchsia::net::LookupIpOptions LookupIpOptions::operator~() const {
+ return ::llcpp::fuchsia::net::LookupIpOptions(static_cast<uint8_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::net::LookupIpOptions LookupIpOptions::operator|(
+ const ::llcpp::fuchsia::net::LookupIpOptions& other) const {
+ return ::llcpp::fuchsia::net::LookupIpOptions(static_cast<uint8_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::net::LookupIpOptions LookupIpOptions::operator&(
+ const ::llcpp::fuchsia::net::LookupIpOptions& other) const {
+ return ::llcpp::fuchsia::net::LookupIpOptions(static_cast<uint8_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::net::LookupIpOptions LookupIpOptions::operator^(
+ const ::llcpp::fuchsia::net::LookupIpOptions& other) const {
+ return ::llcpp::fuchsia::net::LookupIpOptions(static_cast<uint8_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void LookupIpOptions::operator|=(
+ const ::llcpp::fuchsia::net::LookupIpOptions& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void LookupIpOptions::operator&=(
+ const ::llcpp::fuchsia::net::LookupIpOptions& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void LookupIpOptions::operator^=(
+ const ::llcpp::fuchsia::net::LookupIpOptions& other) {
+ this->value_ ^= other.value_;
+}
+
+enum class LookupError : uint32_t {
+ NOT_FOUND = 1u,
+ TRANSIENT = 2u,
+ INVALID_ARGS = 3u,
+ INTERNAL_ERROR = 4u,
+};
+
+
+struct NameLookup_LookupHostname_Result;
+struct Ipv6Address;
+struct Ipv4Address;
+struct IpAddressInfo;
+struct NameLookup_LookupIp_Response;
+struct NameLookup_LookupIp_Result;
+struct IpAddress;
+struct Subnet;
+class NameLookup;
+struct Endpoint;
+
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookup_LookupHostname_ResultTable;
+
+struct NameLookup_LookupHostname_Result {
+ NameLookup_LookupHostname_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static NameLookup_LookupHostname_Result WithResponse(::llcpp::fuchsia::net::NameLookup_LookupHostname_Response* val) {
+ NameLookup_LookupHostname_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::net::NameLookup_LookupHostname_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::net::NameLookup_LookupHostname_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::net::NameLookup_LookupHostname_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::net::NameLookup_LookupHostname_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::net::NameLookup_LookupHostname_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static NameLookup_LookupHostname_Result WithErr(::llcpp::fuchsia::net::LookupError* val) {
+ NameLookup_LookupHostname_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(::llcpp::fuchsia::net::LookupError* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::net::LookupError& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<::llcpp::fuchsia::net::LookupError*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::net::LookupError& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<::llcpp::fuchsia::net::LookupError*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_NameLookup_LookupHostname_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 272;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookup_LookupIp_ResultTable;
+
+struct NameLookup_LookupIp_Result {
+ NameLookup_LookupIp_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static NameLookup_LookupIp_Result WithResponse(::llcpp::fuchsia::net::NameLookup_LookupIp_Response* val) {
+ NameLookup_LookupIp_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::net::NameLookup_LookupIp_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::net::NameLookup_LookupIp_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::net::NameLookup_LookupIp_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::net::NameLookup_LookupIp_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::net::NameLookup_LookupIp_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static NameLookup_LookupIp_Result WithErr(::llcpp::fuchsia::net::LookupError* val) {
+ NameLookup_LookupIp_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(::llcpp::fuchsia::net::LookupError* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::net::LookupError& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<::llcpp::fuchsia::net::LookupError*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::net::LookupError& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<::llcpp::fuchsia::net::LookupError*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_NameLookup_LookupIp_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 5424;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_IpAddressTable;
+
+// Represents an IP address that may be either v4 or v6.
+struct IpAddress {
+ IpAddress() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kIpv4 = 1, // 0x1
+ kIpv6 = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_ipv4() const { return ordinal() == Ordinal::kIpv4; }
+
+ static IpAddress WithIpv4(::llcpp::fuchsia::net::Ipv4Address* val) {
+ IpAddress result;
+ result.set_ipv4(val);
+ return result;
+ }
+
+ void set_ipv4(::llcpp::fuchsia::net::Ipv4Address* elem) {
+ ordinal_ = Ordinal::kIpv4;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::net::Ipv4Address& mutable_ipv4() {
+ ZX_ASSERT(ordinal() == Ordinal::kIpv4);
+ return *static_cast<::llcpp::fuchsia::net::Ipv4Address*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::net::Ipv4Address& ipv4() const {
+ ZX_ASSERT(ordinal() == Ordinal::kIpv4);
+ return *static_cast<::llcpp::fuchsia::net::Ipv4Address*>(envelope_.data);
+ }
+
+ bool is_ipv6() const { return ordinal() == Ordinal::kIpv6; }
+
+ static IpAddress WithIpv6(::llcpp::fuchsia::net::Ipv6Address* val) {
+ IpAddress result;
+ result.set_ipv6(val);
+ return result;
+ }
+
+ void set_ipv6(::llcpp::fuchsia::net::Ipv6Address* elem) {
+ ordinal_ = Ordinal::kIpv6;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::net::Ipv6Address& mutable_ipv6() {
+ ZX_ASSERT(ordinal() == Ordinal::kIpv6);
+ return *static_cast<::llcpp::fuchsia::net::Ipv6Address*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::net::Ipv6Address& ipv6() const {
+ ZX_ASSERT(ordinal() == Ordinal::kIpv6);
+ return *static_cast<::llcpp::fuchsia::net::Ipv6Address*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_IpAddressTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kIpv4 = 1, // 0x1
+ kIpv6 = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_ConnectivityOnNetworkReachableRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_net_ConnectivityOnNetworkReachableEventTable;
+
+class Connectivity final {
+ Connectivity() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.net.Connectivity";
+
+ struct OnNetworkReachableResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool reachable;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_ConnectivityOnNetworkReachableEventTable;
+ 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 EventHandlers {
+ // This is triggered on a state change in network reachability. Clients
+ // should expect that network requests will succeed when `reachable` is
+ // true.
+ fit::callback<zx_status_t(bool reachable)> on_network_reachable;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+
+ public:
+ };
+
+ // 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:
+
+ public:
+ };
+
+ 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_; }
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Connectivity;
+ using _Base = ::fidl::CompleterBase;
+
+ };
+
+ // 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);
+ }
+
+ // This is triggered on a state change in network reachability. Clients
+ // should expect that network requests will succeed when `reachable` is
+ // true.
+ static zx_status_t SendOnNetworkReachableEvent(::zx::unowned_channel _chan, bool reachable);
+
+ // This is triggered on a state change in network reachability. Clients
+ // should expect that network requests will succeed when `reachable` is
+ // true.
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnNetworkReachableEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, bool reachable);
+
+ // This is triggered on a state change in network reachability. Clients
+ // should expect that network requests will succeed when `reachable` is
+ // true.
+ // Messages are encoded in-place.
+ static zx_status_t SendOnNetworkReachableEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnNetworkReachableResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void OnNetworkReachableResponse(const ::fidl::DecodedMessage<Connectivity::OnNetworkReachableResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookup_LookupHostname_ResponseTable;
+
+struct NameLookup_LookupHostname_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_NameLookup_LookupHostname_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 256;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::StringView hostname = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_MacAddressTable;
+
+// A MAC address used to identify a network interface on the data link layer within the network.
+struct MacAddress {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_MacAddressTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 6;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::fidl::Array<uint8_t, 6> octets = {};
+};
+
+constexpr uint64_t MAX_HOSTNAME_SIZE = 255u;
+
+extern "C" const fidl_type_t v1_fuchsia_net_Ipv6AddressTable;
+
+// Ipv6Address is expressed in network byte order, so the most significant byte
+// ("ff" in the address "ff02::1") will be at index 0.
+struct Ipv6Address {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_Ipv6AddressTable;
+ 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;
+
+ ::fidl::Array<uint8_t, 16> addr = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_Ipv4AddressTable;
+
+// Ipv4Address is expressed in network byte order, so the most significant byte
+// ("127" in the address "127.0.0.1") will be at index 0.
+struct Ipv4Address {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_Ipv4AddressTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::fidl::Array<uint8_t, 4> addr = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_IpAddressInfoTable;
+
+struct IpAddressInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_IpAddressInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 5376;
+ static constexpr bool HasPointer = true;
+
+ // All of the IPv4 addresses for the requested hostname.
+ ::fidl::VectorView<::llcpp::fuchsia::net::Ipv4Address> ipv4_addrs = {};
+
+ // All of the IPv6 addresses for the requested hostname.
+ ::fidl::VectorView<::llcpp::fuchsia::net::Ipv6Address> ipv6_addrs = {};
+
+ // The canonical name of the requested hostname (usually the DNS CNAME record, if one exists).
+ ::fidl::StringView canonical_name = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookup_LookupIp_ResponseTable;
+
+struct NameLookup_LookupIp_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_NameLookup_LookupIp_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 5376;
+ static constexpr bool HasPointer = true;
+
+ ::llcpp::fuchsia::net::IpAddressInfo addr = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_SubnetTable;
+
+// Subnet describes an IP subnetwork, where all host IP addresses share the same most significant
+// bits.
+struct Subnet {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_SubnetTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ // The Ipv4 or Ipv6 address. Only the `prefix_len` most significant bits may be set in `addr`;
+ // all bits in the host portion of the address must be zero.
+ ::llcpp::fuchsia::net::IpAddress addr = {};
+
+ // The prefix length of the netmask. E.g. for 192.168.1.0/24, the prefix
+ // length is 24, corresponding to a netmask of 255.255.255.0.
+ // For Ipv4, prefix_len must be in the range [0, 32].
+ // For Ipv6, prefix_len must be in the range [0, 128].
+ uint8_t prefix_len = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookupLookupIpRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookupLookupIpResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookupLookupHostnameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_net_NameLookupLookupHostnameResponseTable;
+
+class NameLookup final {
+ NameLookup() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.net.NameLookup";
+
+ struct LookupIpResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::net::NameLookup_LookupIp_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_NameLookupLookupIpResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 5424;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct LookupIpRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView hostname;
+ ::llcpp::fuchsia::net::LookupIpOptions options;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_NameLookupLookupIpRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 256;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 256;
+ 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 = LookupIpResponse;
+ };
+
+ struct LookupHostnameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::net::NameLookup_LookupHostname_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_NameLookupLookupHostnameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 272;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct LookupHostnameRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::net::IpAddress addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_NameLookupLookupHostnameRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = LookupHostnameResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class LookupIp_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LookupIp_Impl(::zx::unowned_channel _client_end, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options);
+ ~LookupIp_Impl() = default;
+ LookupIp_Impl(LookupIp_Impl&& other) = default;
+ LookupIp_Impl& operator=(LookupIp_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 LookupHostname_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ LookupHostname_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::IpAddress addr);
+ ~LookupHostname_Impl() = default;
+ LookupHostname_Impl(LookupHostname_Impl&& other) = default;
+ LookupHostname_Impl& operator=(LookupHostname_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 LookupIp = LookupIp_Impl<LookupIpResponse>;
+ using LookupHostname = LookupHostname_Impl<LookupHostnameResponse>;
+ };
+
+ // 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 LookupIp_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LookupIp_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options, ::fidl::BytePart _response_buffer);
+ ~LookupIp_Impl() = default;
+ LookupIp_Impl(LookupIp_Impl&& other) = default;
+ LookupIp_Impl& operator=(LookupIp_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 LookupHostname_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ LookupHostname_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::IpAddress addr, ::fidl::BytePart _response_buffer);
+ ~LookupHostname_Impl() = default;
+ LookupHostname_Impl(LookupHostname_Impl&& other) = default;
+ LookupHostname_Impl& operator=(LookupHostname_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 LookupIp = LookupIp_Impl<LookupIpResponse>;
+ using LookupHostname = LookupHostname_Impl<LookupHostnameResponse>;
+ };
+
+ 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_; }
+
+ // Look up a list of IP addresses by hostname.
+ //
+ // If `hostname` is an Internationalized Domain Name, it must be encoded as per RFC 3490.
+ // Allocates 296 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::LookupIp LookupIp(::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options);
+
+ // Look up a list of IP addresses by hostname.
+ //
+ // If `hostname` is an Internationalized Domain Name, it must be encoded as per RFC 3490.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LookupIp LookupIp(::fidl::BytePart _request_buffer, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options, ::fidl::BytePart _response_buffer);
+
+ // Look up a hostname by IP address.
+ // Allocates 368 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::LookupHostname LookupHostname(::llcpp::fuchsia::net::IpAddress addr);
+
+ // Look up a hostname by IP address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::LookupHostname LookupHostname(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::IpAddress addr, ::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:
+
+ // Look up a list of IP addresses by hostname.
+ //
+ // If `hostname` is an Internationalized Domain Name, it must be encoded as per RFC 3490.
+ // Allocates 296 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::LookupIp LookupIp(::zx::unowned_channel _client_end, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options);
+
+ // Look up a list of IP addresses by hostname.
+ //
+ // If `hostname` is an Internationalized Domain Name, it must be encoded as per RFC 3490.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LookupIp LookupIp(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options, ::fidl::BytePart _response_buffer);
+
+ // Look up a hostname by IP address.
+ // Allocates 368 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::LookupHostname LookupHostname(::zx::unowned_channel _client_end, ::llcpp::fuchsia::net::IpAddress addr);
+
+ // Look up a hostname by IP address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::LookupHostname LookupHostname(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::net::IpAddress addr, ::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:
+
+ // Look up a list of IP addresses by hostname.
+ //
+ // If `hostname` is an Internationalized Domain Name, it must be encoded as per RFC 3490.
+ static ::fidl::DecodeResult<LookupIpResponse> LookupIp(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LookupIpRequest> params, ::fidl::BytePart response_buffer);
+
+ // Look up a hostname by IP address.
+ static ::fidl::DecodeResult<LookupHostnameResponse> LookupHostname(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LookupHostnameRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = NameLookup;
+ using _Base = ::fidl::CompleterBase;
+
+ class LookupIpCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::net::NameLookup_LookupIp_Result result);
+ void ReplySuccess(::llcpp::fuchsia::net::IpAddressInfo addr);
+ void ReplyError(LookupError error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::net::NameLookup_LookupIp_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::net::IpAddressInfo addr);
+ void Reply(::fidl::DecodedMessage<LookupIpResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LookupIpCompleter = ::fidl::Completer<LookupIpCompleterBase>;
+
+ virtual void LookupIp(::fidl::StringView hostname, ::llcpp::fuchsia::net::LookupIpOptions options, LookupIpCompleter::Sync _completer) = 0;
+
+ class LookupHostnameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::net::NameLookup_LookupHostname_Result result);
+ void ReplySuccess(::fidl::StringView hostname);
+ void ReplyError(LookupError error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::net::NameLookup_LookupHostname_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::StringView hostname);
+ void Reply(::fidl::DecodedMessage<LookupHostnameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LookupHostnameCompleter = ::fidl::Completer<LookupHostnameCompleterBase>;
+
+ virtual void LookupHostname(::llcpp::fuchsia::net::IpAddress addr, LookupHostnameCompleter::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 LookupIpRequest(const ::fidl::DecodedMessage<NameLookup::LookupIpRequest>& _msg);
+ static void LookupIpResponse(const ::fidl::DecodedMessage<NameLookup::LookupIpResponse>& _msg);
+ static void LookupHostnameRequest(const ::fidl::DecodedMessage<NameLookup::LookupHostnameRequest>& _msg);
+ static void LookupHostnameResponse(const ::fidl::DecodedMessage<NameLookup::LookupHostnameResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_net_EndpointTable;
+
+// Endpoint describes an IP address and port. The network protocol associated
+// with the Endpoint will be known from context or communicated through
+// additional structures.
+struct Endpoint {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_net_EndpointTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ // The IP address of the endpoint.
+ ::llcpp::fuchsia::net::IpAddress addr = {};
+
+ // The port number of the endpoint.
+ uint16_t port = {};
+};
+
+} // namespace net
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::Connectivity::OnNetworkReachableResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::net::Connectivity::OnNetworkReachableResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::net::Connectivity::OnNetworkReachableResponse)
+ == ::llcpp::fuchsia::net::Connectivity::OnNetworkReachableResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::net::Connectivity::OnNetworkReachableResponse, reachable) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::NameLookup_LookupHostname_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::NameLookup_LookupHostname_Response>);
+static_assert(offsetof(::llcpp::fuchsia::net::NameLookup_LookupHostname_Response, hostname) == 0);
+static_assert(sizeof(::llcpp::fuchsia::net::NameLookup_LookupHostname_Response) == ::llcpp::fuchsia::net::NameLookup_LookupHostname_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::MacAddress> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::MacAddress>);
+static_assert(offsetof(::llcpp::fuchsia::net::MacAddress, octets) == 0);
+static_assert(sizeof(::llcpp::fuchsia::net::MacAddress) == ::llcpp::fuchsia::net::MacAddress::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::LookupIpOptions> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::LookupIpOptions>);
+static_assert(sizeof(::llcpp::fuchsia::net::LookupIpOptions) == sizeof(uint8_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::NameLookup_LookupHostname_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::NameLookup_LookupHostname_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::Ipv6Address> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::Ipv6Address>);
+static_assert(offsetof(::llcpp::fuchsia::net::Ipv6Address, addr) == 0);
+static_assert(sizeof(::llcpp::fuchsia::net::Ipv6Address) == ::llcpp::fuchsia::net::Ipv6Address::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::Ipv4Address> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::Ipv4Address>);
+static_assert(offsetof(::llcpp::fuchsia::net::Ipv4Address, addr) == 0);
+static_assert(sizeof(::llcpp::fuchsia::net::Ipv4Address) == ::llcpp::fuchsia::net::Ipv4Address::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::IpAddressInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::IpAddressInfo>);
+static_assert(offsetof(::llcpp::fuchsia::net::IpAddressInfo, ipv4_addrs) == 0);
+static_assert(offsetof(::llcpp::fuchsia::net::IpAddressInfo, ipv6_addrs) == 16);
+static_assert(offsetof(::llcpp::fuchsia::net::IpAddressInfo, canonical_name) == 32);
+static_assert(sizeof(::llcpp::fuchsia::net::IpAddressInfo) == ::llcpp::fuchsia::net::IpAddressInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::NameLookup_LookupIp_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::NameLookup_LookupIp_Response>);
+static_assert(offsetof(::llcpp::fuchsia::net::NameLookup_LookupIp_Response, addr) == 0);
+static_assert(sizeof(::llcpp::fuchsia::net::NameLookup_LookupIp_Response) == ::llcpp::fuchsia::net::NameLookup_LookupIp_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::NameLookup_LookupIp_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::NameLookup_LookupIp_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::IpAddress> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::IpAddress>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::Subnet> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::Subnet>);
+static_assert(offsetof(::llcpp::fuchsia::net::Subnet, addr) == 0);
+static_assert(offsetof(::llcpp::fuchsia::net::Subnet, prefix_len) == 24);
+static_assert(sizeof(::llcpp::fuchsia::net::Subnet) == ::llcpp::fuchsia::net::Subnet::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::NameLookup::LookupIpRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::net::NameLookup::LookupIpRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::net::NameLookup::LookupIpRequest)
+ == ::llcpp::fuchsia::net::NameLookup::LookupIpRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::net::NameLookup::LookupIpRequest, hostname) == 16);
+static_assert(offsetof(::llcpp::fuchsia::net::NameLookup::LookupIpRequest, options) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::NameLookup::LookupIpResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::net::NameLookup::LookupIpResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::net::NameLookup::LookupIpResponse)
+ == ::llcpp::fuchsia::net::NameLookup::LookupIpResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::net::NameLookup::LookupIpResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::NameLookup::LookupHostnameRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::net::NameLookup::LookupHostnameRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::net::NameLookup::LookupHostnameRequest)
+ == ::llcpp::fuchsia::net::NameLookup::LookupHostnameRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::net::NameLookup::LookupHostnameRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::NameLookup::LookupHostnameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::net::NameLookup::LookupHostnameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::net::NameLookup::LookupHostnameResponse)
+ == ::llcpp::fuchsia::net::NameLookup::LookupHostnameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::net::NameLookup::LookupHostnameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::net::Endpoint> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::net::Endpoint>);
+static_assert(offsetof(::llcpp::fuchsia::net::Endpoint, addr) == 0);
+static_assert(offsetof(::llcpp::fuchsia::net::Endpoint, port) == 24);
+static_assert(sizeof(::llcpp::fuchsia::net::Endpoint) == ::llcpp::fuchsia::net::Endpoint::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-paver/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-paver/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..bbfe22a
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-paver/gen/llcpp/fidl.cc
@@ -0,0 +1,3294 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/paver/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace paver {
+
+void ::llcpp::fuchsia::paver::ReadResult::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(ReadResult) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(ReadResult, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(ReadResult, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kPaver_FindDataSink_Ordinal = 0x117a856e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPaver_FindDataSink_GenOrdinal = 0x710a34c6f9c8a0e9lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverFindDataSinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverFindDataSinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPaver_UseBlockDevice_Ordinal = 0x17011fd000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPaver_UseBlockDevice_GenOrdinal = 0x7dbe727cfb90bed5lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverUseBlockDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverUseBlockDeviceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPaver_FindBootManager_Ordinal = 0x20b1ab1800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPaver_FindBootManager_GenOrdinal = 0x5d500b0633102443lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverFindBootManagerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverFindBootManagerResponseTable;
+
+} // namespace
+
+Paver::ResultOf::FindDataSink_Impl::FindDataSink_Impl(::zx::unowned_channel _client_end, ::zx::channel data_sink) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FindDataSinkRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, FindDataSinkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<FindDataSinkRequest*>(_write_bytes);
+ _request.data_sink = std::move(data_sink);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(FindDataSinkRequest));
+ ::fidl::DecodedMessage<FindDataSinkRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Paver::InPlace::FindDataSink(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Paver::ResultOf::FindDataSink Paver::SyncClient::FindDataSink(::zx::channel data_sink) {
+ return ResultOf::FindDataSink(::zx::unowned_channel(this->channel_), std::move(data_sink));
+}
+
+Paver::ResultOf::FindDataSink Paver::Call::FindDataSink(::zx::unowned_channel _client_end, ::zx::channel data_sink) {
+ return ResultOf::FindDataSink(std::move(_client_end), std::move(data_sink));
+}
+
+
+Paver::UnownedResultOf::FindDataSink_Impl::FindDataSink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel data_sink) {
+ if (_request_buffer.capacity() < FindDataSinkRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, FindDataSinkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<FindDataSinkRequest*>(_request_buffer.data());
+ _request.data_sink = std::move(data_sink);
+ _request_buffer.set_actual(sizeof(FindDataSinkRequest));
+ ::fidl::DecodedMessage<FindDataSinkRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Paver::InPlace::FindDataSink(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Paver::UnownedResultOf::FindDataSink Paver::SyncClient::FindDataSink(::fidl::BytePart _request_buffer, ::zx::channel data_sink) {
+ return UnownedResultOf::FindDataSink(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(data_sink));
+}
+
+Paver::UnownedResultOf::FindDataSink Paver::Call::FindDataSink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel data_sink) {
+ return UnownedResultOf::FindDataSink(std::move(_client_end), std::move(_request_buffer), std::move(data_sink));
+}
+
+::fidl::internal::StatusAndError Paver::InPlace::FindDataSink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<FindDataSinkRequest> params) {
+ Paver::SetTransactionHeaderFor::FindDataSinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Paver::ResultOf::UseBlockDevice_Impl::UseBlockDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel block_device, ::zx::channel data_sink) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<UseBlockDeviceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, UseBlockDeviceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<UseBlockDeviceRequest*>(_write_bytes);
+ _request.block_device = std::move(block_device);
+ _request.data_sink = std::move(data_sink);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(UseBlockDeviceRequest));
+ ::fidl::DecodedMessage<UseBlockDeviceRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Paver::InPlace::UseBlockDevice(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Paver::ResultOf::UseBlockDevice Paver::SyncClient::UseBlockDevice(::zx::channel block_device, ::zx::channel data_sink) {
+ return ResultOf::UseBlockDevice(::zx::unowned_channel(this->channel_), std::move(block_device), std::move(data_sink));
+}
+
+Paver::ResultOf::UseBlockDevice Paver::Call::UseBlockDevice(::zx::unowned_channel _client_end, ::zx::channel block_device, ::zx::channel data_sink) {
+ return ResultOf::UseBlockDevice(std::move(_client_end), std::move(block_device), std::move(data_sink));
+}
+
+
+Paver::UnownedResultOf::UseBlockDevice_Impl::UseBlockDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel block_device, ::zx::channel data_sink) {
+ if (_request_buffer.capacity() < UseBlockDeviceRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, UseBlockDeviceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<UseBlockDeviceRequest*>(_request_buffer.data());
+ _request.block_device = std::move(block_device);
+ _request.data_sink = std::move(data_sink);
+ _request_buffer.set_actual(sizeof(UseBlockDeviceRequest));
+ ::fidl::DecodedMessage<UseBlockDeviceRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Paver::InPlace::UseBlockDevice(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Paver::UnownedResultOf::UseBlockDevice Paver::SyncClient::UseBlockDevice(::fidl::BytePart _request_buffer, ::zx::channel block_device, ::zx::channel data_sink) {
+ return UnownedResultOf::UseBlockDevice(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(block_device), std::move(data_sink));
+}
+
+Paver::UnownedResultOf::UseBlockDevice Paver::Call::UseBlockDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel block_device, ::zx::channel data_sink) {
+ return UnownedResultOf::UseBlockDevice(std::move(_client_end), std::move(_request_buffer), std::move(block_device), std::move(data_sink));
+}
+
+::fidl::internal::StatusAndError Paver::InPlace::UseBlockDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UseBlockDeviceRequest> params) {
+ Paver::SetTransactionHeaderFor::UseBlockDeviceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Paver::ResultOf::FindBootManager_Impl::FindBootManager_Impl(::zx::unowned_channel _client_end, ::zx::channel boot_manager, bool initialize) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<FindBootManagerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, FindBootManagerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<FindBootManagerRequest*>(_write_bytes);
+ _request.boot_manager = std::move(boot_manager);
+ _request.initialize = std::move(initialize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(FindBootManagerRequest));
+ ::fidl::DecodedMessage<FindBootManagerRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Paver::InPlace::FindBootManager(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Paver::ResultOf::FindBootManager Paver::SyncClient::FindBootManager(::zx::channel boot_manager, bool initialize) {
+ return ResultOf::FindBootManager(::zx::unowned_channel(this->channel_), std::move(boot_manager), std::move(initialize));
+}
+
+Paver::ResultOf::FindBootManager Paver::Call::FindBootManager(::zx::unowned_channel _client_end, ::zx::channel boot_manager, bool initialize) {
+ return ResultOf::FindBootManager(std::move(_client_end), std::move(boot_manager), std::move(initialize));
+}
+
+
+Paver::UnownedResultOf::FindBootManager_Impl::FindBootManager_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel boot_manager, bool initialize) {
+ if (_request_buffer.capacity() < FindBootManagerRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, FindBootManagerRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<FindBootManagerRequest*>(_request_buffer.data());
+ _request.boot_manager = std::move(boot_manager);
+ _request.initialize = std::move(initialize);
+ _request_buffer.set_actual(sizeof(FindBootManagerRequest));
+ ::fidl::DecodedMessage<FindBootManagerRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Paver::InPlace::FindBootManager(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Paver::UnownedResultOf::FindBootManager Paver::SyncClient::FindBootManager(::fidl::BytePart _request_buffer, ::zx::channel boot_manager, bool initialize) {
+ return UnownedResultOf::FindBootManager(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(boot_manager), std::move(initialize));
+}
+
+Paver::UnownedResultOf::FindBootManager Paver::Call::FindBootManager(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel boot_manager, bool initialize) {
+ return UnownedResultOf::FindBootManager(std::move(_client_end), std::move(_request_buffer), std::move(boot_manager), std::move(initialize));
+}
+
+::fidl::internal::StatusAndError Paver::InPlace::FindBootManager(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<FindBootManagerRequest> params) {
+ Paver::SetTransactionHeaderFor::FindBootManagerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Paver::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kPaver_FindDataSink_Ordinal:
+ case kPaver_FindDataSink_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<FindDataSinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->FindDataSink(std::move(message->data_sink),
+ Interface::FindDataSinkCompleter::Sync(txn));
+ return true;
+ }
+ case kPaver_UseBlockDevice_Ordinal:
+ case kPaver_UseBlockDevice_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<UseBlockDeviceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->UseBlockDevice(std::move(message->block_device), std::move(message->data_sink),
+ Interface::UseBlockDeviceCompleter::Sync(txn));
+ return true;
+ }
+ case kPaver_FindBootManager_Ordinal:
+ case kPaver_FindBootManager_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<FindBootManagerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->FindBootManager(std::move(message->boot_manager), std::move(message->initialize),
+ Interface::FindBootManagerCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Paver::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void Paver::SetTransactionHeaderFor::FindDataSinkRequest(const ::fidl::DecodedMessage<Paver::FindDataSinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPaver_FindDataSink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Paver::SetTransactionHeaderFor::UseBlockDeviceRequest(const ::fidl::DecodedMessage<Paver::UseBlockDeviceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPaver_UseBlockDevice_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Paver::SetTransactionHeaderFor::FindBootManagerRequest(const ::fidl::DecodedMessage<Paver::FindBootManagerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPaver_FindBootManager_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kPayloadStream_RegisterVmo_Ordinal = 0x1044c8d900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPayloadStream_RegisterVmo_GenOrdinal = 0x388d7fe44bcb4clu;
+extern "C" const fidl_type_t v1_fuchsia_paver_PayloadStreamRegisterVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PayloadStreamRegisterVmoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kPayloadStream_ReadData_Ordinal = 0x2c366e3600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kPayloadStream_ReadData_GenOrdinal = 0x2ccde55366318afalu;
+extern "C" const fidl_type_t v1_fuchsia_paver_PayloadStreamReadDataRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PayloadStreamReadDataResponseTable;
+
+} // namespace
+template <>
+PayloadStream::ResultOf::RegisterVmo_Impl<PayloadStream::RegisterVmoResponse>::RegisterVmo_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RegisterVmoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RegisterVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RegisterVmoRequest*>(_write_bytes);
+ _request.vmo = std::move(vmo);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RegisterVmoRequest));
+ ::fidl::DecodedMessage<RegisterVmoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ PayloadStream::InPlace::RegisterVmo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+PayloadStream::ResultOf::RegisterVmo PayloadStream::SyncClient::RegisterVmo(::zx::vmo vmo) {
+ return ResultOf::RegisterVmo(::zx::unowned_channel(this->channel_), std::move(vmo));
+}
+
+PayloadStream::ResultOf::RegisterVmo PayloadStream::Call::RegisterVmo(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ return ResultOf::RegisterVmo(std::move(_client_end), std::move(vmo));
+}
+
+template <>
+PayloadStream::UnownedResultOf::RegisterVmo_Impl<PayloadStream::RegisterVmoResponse>::RegisterVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RegisterVmoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RegisterVmoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RegisterVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RegisterVmoRequest*>(_request_buffer.data());
+ _request.vmo = std::move(vmo);
+ _request_buffer.set_actual(sizeof(RegisterVmoRequest));
+ ::fidl::DecodedMessage<RegisterVmoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ PayloadStream::InPlace::RegisterVmo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+PayloadStream::UnownedResultOf::RegisterVmo PayloadStream::SyncClient::RegisterVmo(::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RegisterVmo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+PayloadStream::UnownedResultOf::RegisterVmo PayloadStream::Call::RegisterVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RegisterVmo(std::move(_client_end), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<PayloadStream::RegisterVmoResponse> PayloadStream::InPlace::RegisterVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RegisterVmoRequest> params, ::fidl::BytePart response_buffer) {
+ PayloadStream::SetTransactionHeaderFor::RegisterVmoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<PayloadStream::RegisterVmoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RegisterVmoRequest, RegisterVmoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<PayloadStream::RegisterVmoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+PayloadStream::ResultOf::ReadData_Impl<PayloadStream::ReadDataResponse>::ReadData_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDataRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadDataRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadDataRequest));
+ ::fidl::DecodedMessage<ReadDataRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ PayloadStream::InPlace::ReadData(std::move(_client_end), Super::response_buffer()));
+}
+
+PayloadStream::ResultOf::ReadData PayloadStream::SyncClient::ReadData() {
+ return ResultOf::ReadData(::zx::unowned_channel(this->channel_));
+}
+
+PayloadStream::ResultOf::ReadData PayloadStream::Call::ReadData(::zx::unowned_channel _client_end) {
+ return ResultOf::ReadData(std::move(_client_end));
+}
+
+template <>
+PayloadStream::UnownedResultOf::ReadData_Impl<PayloadStream::ReadDataResponse>::ReadData_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ReadDataRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ReadDataRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ReadDataRequest));
+ ::fidl::DecodedMessage<ReadDataRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ PayloadStream::InPlace::ReadData(std::move(_client_end), std::move(_response_buffer)));
+}
+
+PayloadStream::UnownedResultOf::ReadData PayloadStream::SyncClient::ReadData(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadData(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+PayloadStream::UnownedResultOf::ReadData PayloadStream::Call::ReadData(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadData(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<PayloadStream::ReadDataResponse> PayloadStream::InPlace::ReadData(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ReadDataRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ReadDataRequest> params(std::move(_request_buffer));
+ PayloadStream::SetTransactionHeaderFor::ReadDataRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<PayloadStream::ReadDataResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadDataRequest, ReadDataResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<PayloadStream::ReadDataResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool PayloadStream::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kPayloadStream_RegisterVmo_Ordinal:
+ case kPayloadStream_RegisterVmo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RegisterVmoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RegisterVmo(std::move(message->vmo),
+ Interface::RegisterVmoCompleter::Sync(txn));
+ return true;
+ }
+ case kPayloadStream_ReadData_Ordinal:
+ case kPayloadStream_ReadData_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadDataRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ReadData(
+ Interface::ReadDataCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool PayloadStream::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void PayloadStream::Interface::RegisterVmoCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RegisterVmoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<RegisterVmoResponse*>(_write_bytes);
+ PayloadStream::SetTransactionHeaderFor::RegisterVmoResponse(
+ ::fidl::DecodedMessage<RegisterVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RegisterVmoResponse::PrimarySize,
+ RegisterVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(RegisterVmoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RegisterVmoResponse>(std::move(_response_bytes)));
+}
+
+void PayloadStream::Interface::RegisterVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < RegisterVmoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<RegisterVmoResponse*>(_buffer.data());
+ PayloadStream::SetTransactionHeaderFor::RegisterVmoResponse(
+ ::fidl::DecodedMessage<RegisterVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RegisterVmoResponse::PrimarySize,
+ RegisterVmoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(RegisterVmoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<RegisterVmoResponse>(std::move(_buffer)));
+}
+
+void PayloadStream::Interface::RegisterVmoCompleterBase::Reply(::fidl::DecodedMessage<RegisterVmoResponse> params) {
+ PayloadStream::SetTransactionHeaderFor::RegisterVmoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void PayloadStream::Interface::ReadDataCompleterBase::Reply(::llcpp::fuchsia::paver::ReadResult result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDataResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ReadDataResponse _response = {};
+ PayloadStream::SetTransactionHeaderFor::ReadDataResponse(
+ ::fidl::DecodedMessage<ReadDataResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDataResponse::PrimarySize,
+ ReadDataResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void PayloadStream::Interface::ReadDataCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::ReadResult result) {
+ if (_buffer.capacity() < ReadDataResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadDataResponse _response = {};
+ PayloadStream::SetTransactionHeaderFor::ReadDataResponse(
+ ::fidl::DecodedMessage<ReadDataResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDataResponse::PrimarySize,
+ ReadDataResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void PayloadStream::Interface::ReadDataCompleterBase::Reply(::fidl::DecodedMessage<ReadDataResponse> params) {
+ PayloadStream::SetTransactionHeaderFor::ReadDataResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void PayloadStream::SetTransactionHeaderFor::RegisterVmoRequest(const ::fidl::DecodedMessage<PayloadStream::RegisterVmoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPayloadStream_RegisterVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void PayloadStream::SetTransactionHeaderFor::RegisterVmoResponse(const ::fidl::DecodedMessage<PayloadStream::RegisterVmoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPayloadStream_RegisterVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void PayloadStream::SetTransactionHeaderFor::ReadDataRequest(const ::fidl::DecodedMessage<PayloadStream::ReadDataRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPayloadStream_ReadData_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void PayloadStream::SetTransactionHeaderFor::ReadDataResponse(const ::fidl::DecodedMessage<PayloadStream::ReadDataResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kPayloadStream_ReadData_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::paver::DataSink_WipeVolume_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DataSink_WipeVolume_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DataSink_WipeVolume_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DataSink_WipeVolume_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(BootManager_QueryConfigurationStatus_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(BootManager_QueryConfigurationStatus_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(BootManager_QueryConfigurationStatus_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(BootManager_QueryActiveConfiguration_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(BootManager_QueryActiveConfiguration_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(BootManager_QueryActiveConfiguration_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBootManager_QueryActiveConfiguration_Ordinal = 0x6d16a64200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_QueryActiveConfiguration_GenOrdinal = 0x71d52acdf59947a4lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerQueryActiveConfigurationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerQueryActiveConfigurationResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_QueryConfigurationStatus_Ordinal = 0x4f9061cd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_QueryConfigurationStatus_GenOrdinal = 0x40822ca9ca68b19alu;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerQueryConfigurationStatusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerQueryConfigurationStatusResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_SetConfigurationActive_Ordinal = 0x3580156000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_SetConfigurationActive_GenOrdinal = 0x14c64074f81f9a7flu;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetConfigurationActiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetConfigurationActiveResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_SetConfigurationUnbootable_Ordinal = 0x4af237e000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_SetConfigurationUnbootable_GenOrdinal = 0x6f8716bf306d197flu;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetConfigurationUnbootableRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetConfigurationUnbootableResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_SetActiveConfigurationHealthy_Ordinal = 0x2ebf3e5300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBootManager_SetActiveConfigurationHealthy_GenOrdinal = 0x3dbfbf3e5ed8aa3lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetActiveConfigurationHealthyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetActiveConfigurationHealthyResponseTable;
+
+} // namespace
+template <>
+BootManager::ResultOf::QueryActiveConfiguration_Impl<BootManager::QueryActiveConfigurationResponse>::QueryActiveConfiguration_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryActiveConfigurationRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, QueryActiveConfigurationRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(QueryActiveConfigurationRequest));
+ ::fidl::DecodedMessage<QueryActiveConfigurationRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BootManager::InPlace::QueryActiveConfiguration(std::move(_client_end), Super::response_buffer()));
+}
+
+BootManager::ResultOf::QueryActiveConfiguration BootManager::SyncClient::QueryActiveConfiguration() {
+ return ResultOf::QueryActiveConfiguration(::zx::unowned_channel(this->channel_));
+}
+
+BootManager::ResultOf::QueryActiveConfiguration BootManager::Call::QueryActiveConfiguration(::zx::unowned_channel _client_end) {
+ return ResultOf::QueryActiveConfiguration(std::move(_client_end));
+}
+
+template <>
+BootManager::UnownedResultOf::QueryActiveConfiguration_Impl<BootManager::QueryActiveConfigurationResponse>::QueryActiveConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(QueryActiveConfigurationRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, QueryActiveConfigurationRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(QueryActiveConfigurationRequest));
+ ::fidl::DecodedMessage<QueryActiveConfigurationRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BootManager::InPlace::QueryActiveConfiguration(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BootManager::UnownedResultOf::QueryActiveConfiguration BootManager::SyncClient::QueryActiveConfiguration(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::QueryActiveConfiguration(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BootManager::UnownedResultOf::QueryActiveConfiguration BootManager::Call::QueryActiveConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::QueryActiveConfiguration(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BootManager::QueryActiveConfigurationResponse> BootManager::InPlace::QueryActiveConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(QueryActiveConfigurationRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<QueryActiveConfigurationRequest> params(std::move(_request_buffer));
+ BootManager::SetTransactionHeaderFor::QueryActiveConfigurationRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::QueryActiveConfigurationResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<QueryActiveConfigurationRequest, QueryActiveConfigurationResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::QueryActiveConfigurationResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BootManager::ResultOf::QueryConfigurationStatus_Impl<BootManager::QueryConfigurationStatusResponse>::QueryConfigurationStatus_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryConfigurationStatusRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, QueryConfigurationStatusRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<QueryConfigurationStatusRequest*>(_write_bytes);
+ _request.configuration = std::move(configuration);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(QueryConfigurationStatusRequest));
+ ::fidl::DecodedMessage<QueryConfigurationStatusRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BootManager::InPlace::QueryConfigurationStatus(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BootManager::ResultOf::QueryConfigurationStatus BootManager::SyncClient::QueryConfigurationStatus(::llcpp::fuchsia::paver::Configuration configuration) {
+ return ResultOf::QueryConfigurationStatus(::zx::unowned_channel(this->channel_), std::move(configuration));
+}
+
+BootManager::ResultOf::QueryConfigurationStatus BootManager::Call::QueryConfigurationStatus(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration) {
+ return ResultOf::QueryConfigurationStatus(std::move(_client_end), std::move(configuration));
+}
+
+template <>
+BootManager::UnownedResultOf::QueryConfigurationStatus_Impl<BootManager::QueryConfigurationStatusResponse>::QueryConfigurationStatus_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < QueryConfigurationStatusRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<QueryConfigurationStatusResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, QueryConfigurationStatusRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<QueryConfigurationStatusRequest*>(_request_buffer.data());
+ _request.configuration = std::move(configuration);
+ _request_buffer.set_actual(sizeof(QueryConfigurationStatusRequest));
+ ::fidl::DecodedMessage<QueryConfigurationStatusRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BootManager::InPlace::QueryConfigurationStatus(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BootManager::UnownedResultOf::QueryConfigurationStatus BootManager::SyncClient::QueryConfigurationStatus(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::QueryConfigurationStatus(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
+}
+
+BootManager::UnownedResultOf::QueryConfigurationStatus BootManager::Call::QueryConfigurationStatus(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::QueryConfigurationStatus(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BootManager::QueryConfigurationStatusResponse> BootManager::InPlace::QueryConfigurationStatus(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<QueryConfigurationStatusRequest> params, ::fidl::BytePart response_buffer) {
+ BootManager::SetTransactionHeaderFor::QueryConfigurationStatusRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::QueryConfigurationStatusResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<QueryConfigurationStatusRequest, QueryConfigurationStatusResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::QueryConfigurationStatusResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BootManager::ResultOf::SetConfigurationActive_Impl<BootManager::SetConfigurationActiveResponse>::SetConfigurationActive_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationActiveRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetConfigurationActiveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigurationActiveRequest*>(_write_bytes);
+ _request.configuration = std::move(configuration);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigurationActiveRequest));
+ ::fidl::DecodedMessage<SetConfigurationActiveRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BootManager::InPlace::SetConfigurationActive(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BootManager::ResultOf::SetConfigurationActive BootManager::SyncClient::SetConfigurationActive(::llcpp::fuchsia::paver::Configuration configuration) {
+ return ResultOf::SetConfigurationActive(::zx::unowned_channel(this->channel_), std::move(configuration));
+}
+
+BootManager::ResultOf::SetConfigurationActive BootManager::Call::SetConfigurationActive(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration) {
+ return ResultOf::SetConfigurationActive(std::move(_client_end), std::move(configuration));
+}
+
+template <>
+BootManager::UnownedResultOf::SetConfigurationActive_Impl<BootManager::SetConfigurationActiveResponse>::SetConfigurationActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetConfigurationActiveRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetConfigurationActiveResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetConfigurationActiveRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigurationActiveRequest*>(_request_buffer.data());
+ _request.configuration = std::move(configuration);
+ _request_buffer.set_actual(sizeof(SetConfigurationActiveRequest));
+ ::fidl::DecodedMessage<SetConfigurationActiveRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BootManager::InPlace::SetConfigurationActive(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BootManager::UnownedResultOf::SetConfigurationActive BootManager::SyncClient::SetConfigurationActive(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfigurationActive(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
+}
+
+BootManager::UnownedResultOf::SetConfigurationActive BootManager::Call::SetConfigurationActive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfigurationActive(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BootManager::SetConfigurationActiveResponse> BootManager::InPlace::SetConfigurationActive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationActiveRequest> params, ::fidl::BytePart response_buffer) {
+ BootManager::SetTransactionHeaderFor::SetConfigurationActiveRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::SetConfigurationActiveResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetConfigurationActiveRequest, SetConfigurationActiveResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::SetConfigurationActiveResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BootManager::ResultOf::SetConfigurationUnbootable_Impl<BootManager::SetConfigurationUnbootableResponse>::SetConfigurationUnbootable_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationUnbootableRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetConfigurationUnbootableRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigurationUnbootableRequest*>(_write_bytes);
+ _request.configuration = std::move(configuration);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigurationUnbootableRequest));
+ ::fidl::DecodedMessage<SetConfigurationUnbootableRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BootManager::InPlace::SetConfigurationUnbootable(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BootManager::ResultOf::SetConfigurationUnbootable BootManager::SyncClient::SetConfigurationUnbootable(::llcpp::fuchsia::paver::Configuration configuration) {
+ return ResultOf::SetConfigurationUnbootable(::zx::unowned_channel(this->channel_), std::move(configuration));
+}
+
+BootManager::ResultOf::SetConfigurationUnbootable BootManager::Call::SetConfigurationUnbootable(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration) {
+ return ResultOf::SetConfigurationUnbootable(std::move(_client_end), std::move(configuration));
+}
+
+template <>
+BootManager::UnownedResultOf::SetConfigurationUnbootable_Impl<BootManager::SetConfigurationUnbootableResponse>::SetConfigurationUnbootable_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetConfigurationUnbootableRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetConfigurationUnbootableResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetConfigurationUnbootableRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConfigurationUnbootableRequest*>(_request_buffer.data());
+ _request.configuration = std::move(configuration);
+ _request_buffer.set_actual(sizeof(SetConfigurationUnbootableRequest));
+ ::fidl::DecodedMessage<SetConfigurationUnbootableRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BootManager::InPlace::SetConfigurationUnbootable(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BootManager::UnownedResultOf::SetConfigurationUnbootable BootManager::SyncClient::SetConfigurationUnbootable(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfigurationUnbootable(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
+}
+
+BootManager::UnownedResultOf::SetConfigurationUnbootable BootManager::Call::SetConfigurationUnbootable(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetConfigurationUnbootable(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BootManager::SetConfigurationUnbootableResponse> BootManager::InPlace::SetConfigurationUnbootable(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationUnbootableRequest> params, ::fidl::BytePart response_buffer) {
+ BootManager::SetTransactionHeaderFor::SetConfigurationUnbootableRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::SetConfigurationUnbootableResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetConfigurationUnbootableRequest, SetConfigurationUnbootableResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::SetConfigurationUnbootableResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BootManager::ResultOf::SetActiveConfigurationHealthy_Impl<BootManager::SetActiveConfigurationHealthyResponse>::SetActiveConfigurationHealthy_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetActiveConfigurationHealthyRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetActiveConfigurationHealthyRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetActiveConfigurationHealthyRequest));
+ ::fidl::DecodedMessage<SetActiveConfigurationHealthyRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BootManager::InPlace::SetActiveConfigurationHealthy(std::move(_client_end), Super::response_buffer()));
+}
+
+BootManager::ResultOf::SetActiveConfigurationHealthy BootManager::SyncClient::SetActiveConfigurationHealthy() {
+ return ResultOf::SetActiveConfigurationHealthy(::zx::unowned_channel(this->channel_));
+}
+
+BootManager::ResultOf::SetActiveConfigurationHealthy BootManager::Call::SetActiveConfigurationHealthy(::zx::unowned_channel _client_end) {
+ return ResultOf::SetActiveConfigurationHealthy(std::move(_client_end));
+}
+
+template <>
+BootManager::UnownedResultOf::SetActiveConfigurationHealthy_Impl<BootManager::SetActiveConfigurationHealthyResponse>::SetActiveConfigurationHealthy_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SetActiveConfigurationHealthyRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SetActiveConfigurationHealthyRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SetActiveConfigurationHealthyRequest));
+ ::fidl::DecodedMessage<SetActiveConfigurationHealthyRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BootManager::InPlace::SetActiveConfigurationHealthy(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BootManager::UnownedResultOf::SetActiveConfigurationHealthy BootManager::SyncClient::SetActiveConfigurationHealthy(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetActiveConfigurationHealthy(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BootManager::UnownedResultOf::SetActiveConfigurationHealthy BootManager::Call::SetActiveConfigurationHealthy(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetActiveConfigurationHealthy(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BootManager::SetActiveConfigurationHealthyResponse> BootManager::InPlace::SetActiveConfigurationHealthy(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SetActiveConfigurationHealthyRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SetActiveConfigurationHealthyRequest> params(std::move(_request_buffer));
+ BootManager::SetTransactionHeaderFor::SetActiveConfigurationHealthyRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::SetActiveConfigurationHealthyResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetActiveConfigurationHealthyRequest, SetActiveConfigurationHealthyResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BootManager::SetActiveConfigurationHealthyResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool BootManager::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBootManager_QueryActiveConfiguration_Ordinal:
+ case kBootManager_QueryActiveConfiguration_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<QueryActiveConfigurationRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->QueryActiveConfiguration(
+ Interface::QueryActiveConfigurationCompleter::Sync(txn));
+ return true;
+ }
+ case kBootManager_QueryConfigurationStatus_Ordinal:
+ case kBootManager_QueryConfigurationStatus_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<QueryConfigurationStatusRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->QueryConfigurationStatus(std::move(message->configuration),
+ Interface::QueryConfigurationStatusCompleter::Sync(txn));
+ return true;
+ }
+ case kBootManager_SetConfigurationActive_Ordinal:
+ case kBootManager_SetConfigurationActive_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetConfigurationActiveRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetConfigurationActive(std::move(message->configuration),
+ Interface::SetConfigurationActiveCompleter::Sync(txn));
+ return true;
+ }
+ case kBootManager_SetConfigurationUnbootable_Ordinal:
+ case kBootManager_SetConfigurationUnbootable_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetConfigurationUnbootableRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetConfigurationUnbootable(std::move(message->configuration),
+ Interface::SetConfigurationUnbootableCompleter::Sync(txn));
+ return true;
+ }
+ case kBootManager_SetActiveConfigurationHealthy_Ordinal:
+ case kBootManager_SetActiveConfigurationHealthy_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetActiveConfigurationHealthyRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->SetActiveConfigurationHealthy(
+ Interface::SetActiveConfigurationHealthyCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool BootManager::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void BootManager::Interface::QueryActiveConfigurationCompleterBase::Reply(::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryActiveConfigurationResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ QueryActiveConfigurationResponse _response = {};
+ BootManager::SetTransactionHeaderFor::QueryActiveConfigurationResponse(
+ ::fidl::DecodedMessage<QueryActiveConfigurationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryActiveConfigurationResponse::PrimarySize,
+ QueryActiveConfigurationResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BootManager::Interface::QueryActiveConfigurationCompleterBase::ReplySuccess(::llcpp::fuchsia::paver::Configuration configuration) {
+ BootManager_QueryActiveConfiguration_Response response;
+ response.configuration = std::move(configuration);
+
+ Reply(BootManager_QueryActiveConfiguration_Result::WithResponse(&response));
+}
+void BootManager::Interface::QueryActiveConfigurationCompleterBase::ReplyError(int32_t error) {
+ Reply(BootManager_QueryActiveConfiguration_Result::WithErr(&error));
+}
+
+void BootManager::Interface::QueryActiveConfigurationCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Result result) {
+ if (_buffer.capacity() < QueryActiveConfigurationResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ QueryActiveConfigurationResponse _response = {};
+ BootManager::SetTransactionHeaderFor::QueryActiveConfigurationResponse(
+ ::fidl::DecodedMessage<QueryActiveConfigurationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryActiveConfigurationResponse::PrimarySize,
+ QueryActiveConfigurationResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BootManager::Interface::QueryActiveConfigurationCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::Configuration configuration) {
+ BootManager_QueryActiveConfiguration_Response response;
+ response.configuration = std::move(configuration);
+
+ Reply(std::move(_buffer), BootManager_QueryActiveConfiguration_Result::WithResponse(&response));
+}
+
+void BootManager::Interface::QueryActiveConfigurationCompleterBase::Reply(::fidl::DecodedMessage<QueryActiveConfigurationResponse> params) {
+ BootManager::SetTransactionHeaderFor::QueryActiveConfigurationResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BootManager::Interface::QueryConfigurationStatusCompleterBase::Reply(::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<QueryConfigurationStatusResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ QueryConfigurationStatusResponse _response = {};
+ BootManager::SetTransactionHeaderFor::QueryConfigurationStatusResponse(
+ ::fidl::DecodedMessage<QueryConfigurationStatusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryConfigurationStatusResponse::PrimarySize,
+ QueryConfigurationStatusResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BootManager::Interface::QueryConfigurationStatusCompleterBase::ReplySuccess(::llcpp::fuchsia::paver::ConfigurationStatus status) {
+ BootManager_QueryConfigurationStatus_Response response;
+ response.status = std::move(status);
+
+ Reply(BootManager_QueryConfigurationStatus_Result::WithResponse(&response));
+}
+void BootManager::Interface::QueryConfigurationStatusCompleterBase::ReplyError(int32_t error) {
+ Reply(BootManager_QueryConfigurationStatus_Result::WithErr(&error));
+}
+
+void BootManager::Interface::QueryConfigurationStatusCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Result result) {
+ if (_buffer.capacity() < QueryConfigurationStatusResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ QueryConfigurationStatusResponse _response = {};
+ BootManager::SetTransactionHeaderFor::QueryConfigurationStatusResponse(
+ ::fidl::DecodedMessage<QueryConfigurationStatusResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ QueryConfigurationStatusResponse::PrimarySize,
+ QueryConfigurationStatusResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BootManager::Interface::QueryConfigurationStatusCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::ConfigurationStatus status) {
+ BootManager_QueryConfigurationStatus_Response response;
+ response.status = std::move(status);
+
+ Reply(std::move(_buffer), BootManager_QueryConfigurationStatus_Result::WithResponse(&response));
+}
+
+void BootManager::Interface::QueryConfigurationStatusCompleterBase::Reply(::fidl::DecodedMessage<QueryConfigurationStatusResponse> params) {
+ BootManager::SetTransactionHeaderFor::QueryConfigurationStatusResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BootManager::Interface::SetConfigurationActiveCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationActiveResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetConfigurationActiveResponse*>(_write_bytes);
+ BootManager::SetTransactionHeaderFor::SetConfigurationActiveResponse(
+ ::fidl::DecodedMessage<SetConfigurationActiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigurationActiveResponse::PrimarySize,
+ SetConfigurationActiveResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigurationActiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigurationActiveResponse>(std::move(_response_bytes)));
+}
+
+void BootManager::Interface::SetConfigurationActiveCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetConfigurationActiveResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetConfigurationActiveResponse*>(_buffer.data());
+ BootManager::SetTransactionHeaderFor::SetConfigurationActiveResponse(
+ ::fidl::DecodedMessage<SetConfigurationActiveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigurationActiveResponse::PrimarySize,
+ SetConfigurationActiveResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetConfigurationActiveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigurationActiveResponse>(std::move(_buffer)));
+}
+
+void BootManager::Interface::SetConfigurationActiveCompleterBase::Reply(::fidl::DecodedMessage<SetConfigurationActiveResponse> params) {
+ BootManager::SetTransactionHeaderFor::SetConfigurationActiveResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BootManager::Interface::SetConfigurationUnbootableCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConfigurationUnbootableResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetConfigurationUnbootableResponse*>(_write_bytes);
+ BootManager::SetTransactionHeaderFor::SetConfigurationUnbootableResponse(
+ ::fidl::DecodedMessage<SetConfigurationUnbootableResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigurationUnbootableResponse::PrimarySize,
+ SetConfigurationUnbootableResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConfigurationUnbootableResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigurationUnbootableResponse>(std::move(_response_bytes)));
+}
+
+void BootManager::Interface::SetConfigurationUnbootableCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetConfigurationUnbootableResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetConfigurationUnbootableResponse*>(_buffer.data());
+ BootManager::SetTransactionHeaderFor::SetConfigurationUnbootableResponse(
+ ::fidl::DecodedMessage<SetConfigurationUnbootableResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetConfigurationUnbootableResponse::PrimarySize,
+ SetConfigurationUnbootableResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetConfigurationUnbootableResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetConfigurationUnbootableResponse>(std::move(_buffer)));
+}
+
+void BootManager::Interface::SetConfigurationUnbootableCompleterBase::Reply(::fidl::DecodedMessage<SetConfigurationUnbootableResponse> params) {
+ BootManager::SetTransactionHeaderFor::SetConfigurationUnbootableResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BootManager::Interface::SetActiveConfigurationHealthyCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetActiveConfigurationHealthyResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetActiveConfigurationHealthyResponse*>(_write_bytes);
+ BootManager::SetTransactionHeaderFor::SetActiveConfigurationHealthyResponse(
+ ::fidl::DecodedMessage<SetActiveConfigurationHealthyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetActiveConfigurationHealthyResponse::PrimarySize,
+ SetActiveConfigurationHealthyResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetActiveConfigurationHealthyResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetActiveConfigurationHealthyResponse>(std::move(_response_bytes)));
+}
+
+void BootManager::Interface::SetActiveConfigurationHealthyCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < SetActiveConfigurationHealthyResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetActiveConfigurationHealthyResponse*>(_buffer.data());
+ BootManager::SetTransactionHeaderFor::SetActiveConfigurationHealthyResponse(
+ ::fidl::DecodedMessage<SetActiveConfigurationHealthyResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetActiveConfigurationHealthyResponse::PrimarySize,
+ SetActiveConfigurationHealthyResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(SetActiveConfigurationHealthyResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetActiveConfigurationHealthyResponse>(std::move(_buffer)));
+}
+
+void BootManager::Interface::SetActiveConfigurationHealthyCompleterBase::Reply(::fidl::DecodedMessage<SetActiveConfigurationHealthyResponse> params) {
+ BootManager::SetTransactionHeaderFor::SetActiveConfigurationHealthyResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void BootManager::SetTransactionHeaderFor::QueryActiveConfigurationRequest(const ::fidl::DecodedMessage<BootManager::QueryActiveConfigurationRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_QueryActiveConfiguration_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BootManager::SetTransactionHeaderFor::QueryActiveConfigurationResponse(const ::fidl::DecodedMessage<BootManager::QueryActiveConfigurationResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_QueryActiveConfiguration_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BootManager::SetTransactionHeaderFor::QueryConfigurationStatusRequest(const ::fidl::DecodedMessage<BootManager::QueryConfigurationStatusRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_QueryConfigurationStatus_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BootManager::SetTransactionHeaderFor::QueryConfigurationStatusResponse(const ::fidl::DecodedMessage<BootManager::QueryConfigurationStatusResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_QueryConfigurationStatus_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BootManager::SetTransactionHeaderFor::SetConfigurationActiveRequest(const ::fidl::DecodedMessage<BootManager::SetConfigurationActiveRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_SetConfigurationActive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BootManager::SetTransactionHeaderFor::SetConfigurationActiveResponse(const ::fidl::DecodedMessage<BootManager::SetConfigurationActiveResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_SetConfigurationActive_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BootManager::SetTransactionHeaderFor::SetConfigurationUnbootableRequest(const ::fidl::DecodedMessage<BootManager::SetConfigurationUnbootableRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_SetConfigurationUnbootable_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BootManager::SetTransactionHeaderFor::SetConfigurationUnbootableResponse(const ::fidl::DecodedMessage<BootManager::SetConfigurationUnbootableResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_SetConfigurationUnbootable_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BootManager::SetTransactionHeaderFor::SetActiveConfigurationHealthyRequest(const ::fidl::DecodedMessage<BootManager::SetActiveConfigurationHealthyRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_SetActiveConfigurationHealthy_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BootManager::SetTransactionHeaderFor::SetActiveConfigurationHealthyResponse(const ::fidl::DecodedMessage<BootManager::SetActiveConfigurationHealthyResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBootManager_SetActiveConfigurationHealthy_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::paver::DataSink_ReadAsset_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DataSink_ReadAsset_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DataSink_ReadAsset_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DataSink_ReadAsset_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDataSink_ReadAsset_Ordinal = 0x5726c2ad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_ReadAsset_GenOrdinal = 0x125a23e561007898lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkReadAssetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkReadAssetResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WriteAsset_Ordinal = 0x60e03b7200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WriteAsset_GenOrdinal = 0x516839ce76c4d0a9lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteAssetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteAssetResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WriteVolumes_Ordinal = 0x5df348af00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WriteVolumes_GenOrdinal = 0x5ee32c861d0259dflu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteVolumesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteVolumesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WriteBootloader_Ordinal = 0x7d89106a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WriteBootloader_GenOrdinal = 0x647f7011b9521b5lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteBootloaderRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteBootloaderResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WriteDataFile_Ordinal = 0x7c0cf22700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WriteDataFile_GenOrdinal = 0x6ce95417166b4f56lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteDataFileRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteDataFileResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WipeVolume_Ordinal = 0x6ab81ba00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDataSink_WipeVolume_GenOrdinal = 0x250dfc2575c27f6clu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWipeVolumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWipeVolumeResponseTable;
+
+} // namespace
+template <>
+DataSink::ResultOf::ReadAsset_Impl<DataSink::ReadAssetResponse>::ReadAsset_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAssetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadAssetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAssetRequest*>(_write_bytes);
+ _request.configuration = std::move(configuration);
+ _request.asset = std::move(asset);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadAssetRequest));
+ ::fidl::DecodedMessage<ReadAssetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DataSink::InPlace::ReadAsset(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DataSink::ResultOf::ReadAsset DataSink::SyncClient::ReadAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset) {
+ return ResultOf::ReadAsset(::zx::unowned_channel(this->channel_), std::move(configuration), std::move(asset));
+}
+
+DataSink::ResultOf::ReadAsset DataSink::Call::ReadAsset(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset) {
+ return ResultOf::ReadAsset(std::move(_client_end), std::move(configuration), std::move(asset));
+}
+
+template <>
+DataSink::UnownedResultOf::ReadAsset_Impl<DataSink::ReadAssetResponse>::ReadAsset_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadAssetRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadAssetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadAssetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAssetRequest*>(_request_buffer.data());
+ _request.configuration = std::move(configuration);
+ _request.asset = std::move(asset);
+ _request_buffer.set_actual(sizeof(ReadAssetRequest));
+ ::fidl::DecodedMessage<ReadAssetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DataSink::InPlace::ReadAsset(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DataSink::UnownedResultOf::ReadAsset DataSink::SyncClient::ReadAsset(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAsset(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(asset), std::move(_response_buffer));
+}
+
+DataSink::UnownedResultOf::ReadAsset DataSink::Call::ReadAsset(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAsset(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(asset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DataSink::ReadAssetResponse> DataSink::InPlace::ReadAsset(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAssetRequest> params, ::fidl::BytePart response_buffer) {
+ DataSink::SetTransactionHeaderFor::ReadAssetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::ReadAssetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadAssetRequest, ReadAssetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::ReadAssetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DataSink::ResultOf::WriteAsset_Impl<DataSink::WriteAssetResponse>::WriteAsset_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAssetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WriteAssetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteAssetRequest*>(_write_bytes);
+ _request.configuration = std::move(configuration);
+ _request.asset = std::move(asset);
+ _request.payload = std::move(payload);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteAssetRequest));
+ ::fidl::DecodedMessage<WriteAssetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DataSink::InPlace::WriteAsset(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DataSink::ResultOf::WriteAsset DataSink::SyncClient::WriteAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteAsset(::zx::unowned_channel(this->channel_), std::move(configuration), std::move(asset), std::move(payload));
+}
+
+DataSink::ResultOf::WriteAsset DataSink::Call::WriteAsset(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteAsset(std::move(_client_end), std::move(configuration), std::move(asset), std::move(payload));
+}
+
+template <>
+DataSink::UnownedResultOf::WriteAsset_Impl<DataSink::WriteAssetResponse>::WriteAsset_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteAssetRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteAssetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WriteAssetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteAssetRequest*>(_request_buffer.data());
+ _request.configuration = std::move(configuration);
+ _request.asset = std::move(asset);
+ _request.payload = std::move(payload);
+ _request_buffer.set_actual(sizeof(WriteAssetRequest));
+ ::fidl::DecodedMessage<WriteAssetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DataSink::InPlace::WriteAsset(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DataSink::UnownedResultOf::WriteAsset DataSink::SyncClient::WriteAsset(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAsset(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(asset), std::move(payload), std::move(_response_buffer));
+}
+
+DataSink::UnownedResultOf::WriteAsset DataSink::Call::WriteAsset(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAsset(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(asset), std::move(payload), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DataSink::WriteAssetResponse> DataSink::InPlace::WriteAsset(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAssetRequest> params, ::fidl::BytePart response_buffer) {
+ DataSink::SetTransactionHeaderFor::WriteAssetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WriteAssetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteAssetRequest, WriteAssetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WriteAssetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DataSink::ResultOf::WriteVolumes_Impl<DataSink::WriteVolumesResponse>::WriteVolumes_Impl(::zx::unowned_channel _client_end, ::zx::channel payload) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteVolumesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WriteVolumesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteVolumesRequest*>(_write_bytes);
+ _request.payload = std::move(payload);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteVolumesRequest));
+ ::fidl::DecodedMessage<WriteVolumesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DataSink::InPlace::WriteVolumes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DataSink::ResultOf::WriteVolumes DataSink::SyncClient::WriteVolumes(::zx::channel payload) {
+ return ResultOf::WriteVolumes(::zx::unowned_channel(this->channel_), std::move(payload));
+}
+
+DataSink::ResultOf::WriteVolumes DataSink::Call::WriteVolumes(::zx::unowned_channel _client_end, ::zx::channel payload) {
+ return ResultOf::WriteVolumes(std::move(_client_end), std::move(payload));
+}
+
+template <>
+DataSink::UnownedResultOf::WriteVolumes_Impl<DataSink::WriteVolumesResponse>::WriteVolumes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteVolumesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteVolumesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WriteVolumesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteVolumesRequest*>(_request_buffer.data());
+ _request.payload = std::move(payload);
+ _request_buffer.set_actual(sizeof(WriteVolumesRequest));
+ ::fidl::DecodedMessage<WriteVolumesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DataSink::InPlace::WriteVolumes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DataSink::UnownedResultOf::WriteVolumes DataSink::SyncClient::WriteVolumes(::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteVolumes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(payload), std::move(_response_buffer));
+}
+
+DataSink::UnownedResultOf::WriteVolumes DataSink::Call::WriteVolumes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteVolumes(std::move(_client_end), std::move(_request_buffer), std::move(payload), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DataSink::WriteVolumesResponse> DataSink::InPlace::WriteVolumes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteVolumesRequest> params, ::fidl::BytePart response_buffer) {
+ DataSink::SetTransactionHeaderFor::WriteVolumesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WriteVolumesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteVolumesRequest, WriteVolumesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WriteVolumesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DataSink::ResultOf::WriteBootloader_Impl<DataSink::WriteBootloaderResponse>::WriteBootloader_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::mem::Buffer payload) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteBootloaderRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WriteBootloaderRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteBootloaderRequest*>(_write_bytes);
+ _request.payload = std::move(payload);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteBootloaderRequest));
+ ::fidl::DecodedMessage<WriteBootloaderRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DataSink::InPlace::WriteBootloader(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DataSink::ResultOf::WriteBootloader DataSink::SyncClient::WriteBootloader(::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteBootloader(::zx::unowned_channel(this->channel_), std::move(payload));
+}
+
+DataSink::ResultOf::WriteBootloader DataSink::Call::WriteBootloader(::zx::unowned_channel _client_end, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteBootloader(std::move(_client_end), std::move(payload));
+}
+
+template <>
+DataSink::UnownedResultOf::WriteBootloader_Impl<DataSink::WriteBootloaderResponse>::WriteBootloader_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteBootloaderRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteBootloaderResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WriteBootloaderRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteBootloaderRequest*>(_request_buffer.data());
+ _request.payload = std::move(payload);
+ _request_buffer.set_actual(sizeof(WriteBootloaderRequest));
+ ::fidl::DecodedMessage<WriteBootloaderRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DataSink::InPlace::WriteBootloader(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DataSink::UnownedResultOf::WriteBootloader DataSink::SyncClient::WriteBootloader(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteBootloader(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(payload), std::move(_response_buffer));
+}
+
+DataSink::UnownedResultOf::WriteBootloader DataSink::Call::WriteBootloader(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteBootloader(std::move(_client_end), std::move(_request_buffer), std::move(payload), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DataSink::WriteBootloaderResponse> DataSink::InPlace::WriteBootloader(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteBootloaderRequest> params, ::fidl::BytePart response_buffer) {
+ DataSink::SetTransactionHeaderFor::WriteBootloaderRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WriteBootloaderResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteBootloaderRequest, WriteBootloaderResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WriteBootloaderResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DataSink::ResultOf::WriteDataFile_Impl<DataSink::WriteDataFileResponse>::WriteDataFile_Impl(::zx::unowned_channel _client_end, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteDataFileRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteDataFileRequest _request = {};
+ _request.filename = std::move(filename);
+ _request.payload = std::move(payload);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteDataFileRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DataSink::InPlace::WriteDataFile(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DataSink::ResultOf::WriteDataFile DataSink::SyncClient::WriteDataFile(::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteDataFile(::zx::unowned_channel(this->channel_), std::move(filename), std::move(payload));
+}
+
+DataSink::ResultOf::WriteDataFile DataSink::Call::WriteDataFile(::zx::unowned_channel _client_end, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteDataFile(std::move(_client_end), std::move(filename), std::move(payload));
+}
+
+template <>
+DataSink::UnownedResultOf::WriteDataFile_Impl<DataSink::WriteDataFileResponse>::WriteDataFile_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteDataFileRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteDataFileResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteDataFileRequest _request = {};
+ _request.filename = std::move(filename);
+ _request.payload = std::move(payload);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteDataFileRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DataSink::InPlace::WriteDataFile(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DataSink::UnownedResultOf::WriteDataFile DataSink::SyncClient::WriteDataFile(::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteDataFile(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(filename), std::move(payload), std::move(_response_buffer));
+}
+
+DataSink::UnownedResultOf::WriteDataFile DataSink::Call::WriteDataFile(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteDataFile(std::move(_client_end), std::move(_request_buffer), std::move(filename), std::move(payload), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DataSink::WriteDataFileResponse> DataSink::InPlace::WriteDataFile(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteDataFileRequest> params, ::fidl::BytePart response_buffer) {
+ DataSink::SetTransactionHeaderFor::WriteDataFileRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WriteDataFileResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteDataFileRequest, WriteDataFileResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WriteDataFileResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DataSink::ResultOf::WipeVolume_Impl<DataSink::WipeVolumeResponse>::WipeVolume_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WipeVolumeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WipeVolumeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WipeVolumeRequest));
+ ::fidl::DecodedMessage<WipeVolumeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DataSink::InPlace::WipeVolume(std::move(_client_end), Super::response_buffer()));
+}
+
+DataSink::ResultOf::WipeVolume DataSink::SyncClient::WipeVolume() {
+ return ResultOf::WipeVolume(::zx::unowned_channel(this->channel_));
+}
+
+DataSink::ResultOf::WipeVolume DataSink::Call::WipeVolume(::zx::unowned_channel _client_end) {
+ return ResultOf::WipeVolume(std::move(_client_end));
+}
+
+template <>
+DataSink::UnownedResultOf::WipeVolume_Impl<DataSink::WipeVolumeResponse>::WipeVolume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WipeVolumeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WipeVolumeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WipeVolumeRequest));
+ ::fidl::DecodedMessage<WipeVolumeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DataSink::InPlace::WipeVolume(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DataSink::UnownedResultOf::WipeVolume DataSink::SyncClient::WipeVolume(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WipeVolume(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DataSink::UnownedResultOf::WipeVolume DataSink::Call::WipeVolume(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WipeVolume(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DataSink::WipeVolumeResponse> DataSink::InPlace::WipeVolume(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WipeVolumeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WipeVolumeRequest> params(std::move(_request_buffer));
+ DataSink::SetTransactionHeaderFor::WipeVolumeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WipeVolumeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WipeVolumeRequest, WipeVolumeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DataSink::WipeVolumeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DataSink::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDataSink_ReadAsset_Ordinal:
+ case kDataSink_ReadAsset_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadAssetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReadAsset(std::move(message->configuration), std::move(message->asset),
+ Interface::ReadAssetCompleter::Sync(txn));
+ return true;
+ }
+ case kDataSink_WriteAsset_Ordinal:
+ case kDataSink_WriteAsset_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteAssetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteAsset(std::move(message->configuration), std::move(message->asset), std::move(message->payload),
+ Interface::WriteAssetCompleter::Sync(txn));
+ return true;
+ }
+ case kDataSink_WriteVolumes_Ordinal:
+ case kDataSink_WriteVolumes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteVolumesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteVolumes(std::move(message->payload),
+ Interface::WriteVolumesCompleter::Sync(txn));
+ return true;
+ }
+ case kDataSink_WriteBootloader_Ordinal:
+ case kDataSink_WriteBootloader_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteBootloaderRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteBootloader(std::move(message->payload),
+ Interface::WriteBootloaderCompleter::Sync(txn));
+ return true;
+ }
+ case kDataSink_WriteDataFile_Ordinal:
+ case kDataSink_WriteDataFile_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteDataFileRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteDataFile(std::move(message->filename), std::move(message->payload),
+ Interface::WriteDataFileCompleter::Sync(txn));
+ return true;
+ }
+ case kDataSink_WipeVolume_Ordinal:
+ case kDataSink_WipeVolume_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WipeVolumeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WipeVolume(
+ Interface::WipeVolumeCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DataSink::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DataSink::Interface::ReadAssetCompleterBase::Reply(::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAssetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ReadAssetResponse _response = {};
+ DataSink::SetTransactionHeaderFor::ReadAssetResponse(
+ ::fidl::DecodedMessage<ReadAssetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAssetResponse::PrimarySize,
+ ReadAssetResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DataSink::Interface::ReadAssetCompleterBase::ReplySuccess(::llcpp::fuchsia::mem::Buffer asset) {
+ DataSink_ReadAsset_Response response;
+ response.asset = std::move(asset);
+
+ Reply(DataSink_ReadAsset_Result::WithResponse(&response));
+}
+void DataSink::Interface::ReadAssetCompleterBase::ReplyError(int32_t error) {
+ Reply(DataSink_ReadAsset_Result::WithErr(&error));
+}
+
+void DataSink::Interface::ReadAssetCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result) {
+ if (_buffer.capacity() < ReadAssetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadAssetResponse _response = {};
+ DataSink::SetTransactionHeaderFor::ReadAssetResponse(
+ ::fidl::DecodedMessage<ReadAssetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAssetResponse::PrimarySize,
+ ReadAssetResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DataSink::Interface::ReadAssetCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::mem::Buffer asset) {
+ DataSink_ReadAsset_Response response;
+ response.asset = std::move(asset);
+
+ Reply(std::move(_buffer), DataSink_ReadAsset_Result::WithResponse(&response));
+}
+
+void DataSink::Interface::ReadAssetCompleterBase::Reply(::fidl::DecodedMessage<ReadAssetResponse> params) {
+ DataSink::SetTransactionHeaderFor::ReadAssetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DataSink::Interface::WriteAssetCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAssetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteAssetResponse*>(_write_bytes);
+ DataSink::SetTransactionHeaderFor::WriteAssetResponse(
+ ::fidl::DecodedMessage<WriteAssetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAssetResponse::PrimarySize,
+ WriteAssetResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteAssetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteAssetResponse>(std::move(_response_bytes)));
+}
+
+void DataSink::Interface::WriteAssetCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WriteAssetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteAssetResponse*>(_buffer.data());
+ DataSink::SetTransactionHeaderFor::WriteAssetResponse(
+ ::fidl::DecodedMessage<WriteAssetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAssetResponse::PrimarySize,
+ WriteAssetResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WriteAssetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteAssetResponse>(std::move(_buffer)));
+}
+
+void DataSink::Interface::WriteAssetCompleterBase::Reply(::fidl::DecodedMessage<WriteAssetResponse> params) {
+ DataSink::SetTransactionHeaderFor::WriteAssetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DataSink::Interface::WriteVolumesCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteVolumesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteVolumesResponse*>(_write_bytes);
+ DataSink::SetTransactionHeaderFor::WriteVolumesResponse(
+ ::fidl::DecodedMessage<WriteVolumesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteVolumesResponse::PrimarySize,
+ WriteVolumesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteVolumesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteVolumesResponse>(std::move(_response_bytes)));
+}
+
+void DataSink::Interface::WriteVolumesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WriteVolumesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteVolumesResponse*>(_buffer.data());
+ DataSink::SetTransactionHeaderFor::WriteVolumesResponse(
+ ::fidl::DecodedMessage<WriteVolumesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteVolumesResponse::PrimarySize,
+ WriteVolumesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WriteVolumesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteVolumesResponse>(std::move(_buffer)));
+}
+
+void DataSink::Interface::WriteVolumesCompleterBase::Reply(::fidl::DecodedMessage<WriteVolumesResponse> params) {
+ DataSink::SetTransactionHeaderFor::WriteVolumesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DataSink::Interface::WriteBootloaderCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteBootloaderResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteBootloaderResponse*>(_write_bytes);
+ DataSink::SetTransactionHeaderFor::WriteBootloaderResponse(
+ ::fidl::DecodedMessage<WriteBootloaderResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteBootloaderResponse::PrimarySize,
+ WriteBootloaderResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteBootloaderResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteBootloaderResponse>(std::move(_response_bytes)));
+}
+
+void DataSink::Interface::WriteBootloaderCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WriteBootloaderResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteBootloaderResponse*>(_buffer.data());
+ DataSink::SetTransactionHeaderFor::WriteBootloaderResponse(
+ ::fidl::DecodedMessage<WriteBootloaderResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteBootloaderResponse::PrimarySize,
+ WriteBootloaderResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WriteBootloaderResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteBootloaderResponse>(std::move(_buffer)));
+}
+
+void DataSink::Interface::WriteBootloaderCompleterBase::Reply(::fidl::DecodedMessage<WriteBootloaderResponse> params) {
+ DataSink::SetTransactionHeaderFor::WriteBootloaderResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DataSink::Interface::WriteDataFileCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteDataFileResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteDataFileResponse*>(_write_bytes);
+ DataSink::SetTransactionHeaderFor::WriteDataFileResponse(
+ ::fidl::DecodedMessage<WriteDataFileResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteDataFileResponse::PrimarySize,
+ WriteDataFileResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteDataFileResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteDataFileResponse>(std::move(_response_bytes)));
+}
+
+void DataSink::Interface::WriteDataFileCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WriteDataFileResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteDataFileResponse*>(_buffer.data());
+ DataSink::SetTransactionHeaderFor::WriteDataFileResponse(
+ ::fidl::DecodedMessage<WriteDataFileResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteDataFileResponse::PrimarySize,
+ WriteDataFileResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WriteDataFileResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteDataFileResponse>(std::move(_buffer)));
+}
+
+void DataSink::Interface::WriteDataFileCompleterBase::Reply(::fidl::DecodedMessage<WriteDataFileResponse> params) {
+ DataSink::SetTransactionHeaderFor::WriteDataFileResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DataSink::Interface::WipeVolumeCompleterBase::Reply(::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WipeVolumeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ WipeVolumeResponse _response = {};
+ DataSink::SetTransactionHeaderFor::WipeVolumeResponse(
+ ::fidl::DecodedMessage<WipeVolumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WipeVolumeResponse::PrimarySize,
+ WipeVolumeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DataSink::Interface::WipeVolumeCompleterBase::ReplySuccess(::zx::channel volume) {
+ DataSink_WipeVolume_Response response;
+ response.volume = std::move(volume);
+
+ Reply(DataSink_WipeVolume_Result::WithResponse(&response));
+}
+void DataSink::Interface::WipeVolumeCompleterBase::ReplyError(int32_t error) {
+ Reply(DataSink_WipeVolume_Result::WithErr(&error));
+}
+
+void DataSink::Interface::WipeVolumeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result) {
+ if (_buffer.capacity() < WipeVolumeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WipeVolumeResponse _response = {};
+ DataSink::SetTransactionHeaderFor::WipeVolumeResponse(
+ ::fidl::DecodedMessage<WipeVolumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WipeVolumeResponse::PrimarySize,
+ WipeVolumeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DataSink::Interface::WipeVolumeCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::channel volume) {
+ DataSink_WipeVolume_Response response;
+ response.volume = std::move(volume);
+
+ Reply(std::move(_buffer), DataSink_WipeVolume_Result::WithResponse(&response));
+}
+
+void DataSink::Interface::WipeVolumeCompleterBase::Reply(::fidl::DecodedMessage<WipeVolumeResponse> params) {
+ DataSink::SetTransactionHeaderFor::WipeVolumeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DataSink::SetTransactionHeaderFor::ReadAssetRequest(const ::fidl::DecodedMessage<DataSink::ReadAssetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_ReadAsset_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DataSink::SetTransactionHeaderFor::ReadAssetResponse(const ::fidl::DecodedMessage<DataSink::ReadAssetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_ReadAsset_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DataSink::SetTransactionHeaderFor::WriteAssetRequest(const ::fidl::DecodedMessage<DataSink::WriteAssetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WriteAsset_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DataSink::SetTransactionHeaderFor::WriteAssetResponse(const ::fidl::DecodedMessage<DataSink::WriteAssetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WriteAsset_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DataSink::SetTransactionHeaderFor::WriteVolumesRequest(const ::fidl::DecodedMessage<DataSink::WriteVolumesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WriteVolumes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DataSink::SetTransactionHeaderFor::WriteVolumesResponse(const ::fidl::DecodedMessage<DataSink::WriteVolumesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WriteVolumes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DataSink::SetTransactionHeaderFor::WriteBootloaderRequest(const ::fidl::DecodedMessage<DataSink::WriteBootloaderRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WriteBootloader_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DataSink::SetTransactionHeaderFor::WriteBootloaderResponse(const ::fidl::DecodedMessage<DataSink::WriteBootloaderResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WriteBootloader_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DataSink::SetTransactionHeaderFor::WriteDataFileRequest(const ::fidl::DecodedMessage<DataSink::WriteDataFileRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WriteDataFile_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DataSink::SetTransactionHeaderFor::WriteDataFileResponse(const ::fidl::DecodedMessage<DataSink::WriteDataFileResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WriteDataFile_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DataSink::SetTransactionHeaderFor::WipeVolumeRequest(const ::fidl::DecodedMessage<DataSink::WipeVolumeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WipeVolume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DataSink::SetTransactionHeaderFor::WipeVolumeResponse(const ::fidl::DecodedMessage<DataSink::WipeVolumeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDataSink_WipeVolume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_ReadAsset_Ordinal = 0x5726c2ad00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_ReadAsset_GenOrdinal = 0x125a23e561007898lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkReadAssetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkReadAssetResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WriteAsset_Ordinal = 0x60e03b7200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WriteAsset_GenOrdinal = 0x516839ce76c4d0a9lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteAssetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteAssetResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WriteVolumes_Ordinal = 0x5df348af00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WriteVolumes_GenOrdinal = 0x5ee32c861d0259dflu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteVolumesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteVolumesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WriteBootloader_Ordinal = 0x7d89106a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WriteBootloader_GenOrdinal = 0x647f7011b9521b5lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteBootloaderRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteBootloaderResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WriteDataFile_Ordinal = 0x7c0cf22700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WriteDataFile_GenOrdinal = 0x6ce95417166b4f56lu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteDataFileRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteDataFileResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WipeVolume_Ordinal = 0x6ab81ba00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WipeVolume_GenOrdinal = 0x250dfc2575c27f6clu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWipeVolumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWipeVolumeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_InitializePartitionTables_Ordinal = 0x6c2391d400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_InitializePartitionTables_GenOrdinal = 0x4c798b3813ea9f7elu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkInitializePartitionTablesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkInitializePartitionTablesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WipePartitionTables_Ordinal = 0x5e89186e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDynamicDataSink_WipePartitionTables_GenOrdinal = 0x797c0ebeedaf2cclu;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWipePartitionTablesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWipePartitionTablesResponseTable;
+
+} // namespace
+template <>
+DynamicDataSink::ResultOf::ReadAsset_Impl<DynamicDataSink::ReadAssetResponse>::ReadAsset_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAssetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadAssetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAssetRequest*>(_write_bytes);
+ _request.configuration = std::move(configuration);
+ _request.asset = std::move(asset);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadAssetRequest));
+ ::fidl::DecodedMessage<ReadAssetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DynamicDataSink::InPlace::ReadAsset(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DynamicDataSink::ResultOf::ReadAsset DynamicDataSink::SyncClient::ReadAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset) {
+ return ResultOf::ReadAsset(::zx::unowned_channel(this->channel_), std::move(configuration), std::move(asset));
+}
+
+DynamicDataSink::ResultOf::ReadAsset DynamicDataSink::Call::ReadAsset(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset) {
+ return ResultOf::ReadAsset(std::move(_client_end), std::move(configuration), std::move(asset));
+}
+
+template <>
+DynamicDataSink::UnownedResultOf::ReadAsset_Impl<DynamicDataSink::ReadAssetResponse>::ReadAsset_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ReadAssetRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ReadAssetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ReadAssetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ReadAssetRequest*>(_request_buffer.data());
+ _request.configuration = std::move(configuration);
+ _request.asset = std::move(asset);
+ _request_buffer.set_actual(sizeof(ReadAssetRequest));
+ ::fidl::DecodedMessage<ReadAssetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DynamicDataSink::InPlace::ReadAsset(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DynamicDataSink::UnownedResultOf::ReadAsset DynamicDataSink::SyncClient::ReadAsset(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAsset(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(asset), std::move(_response_buffer));
+}
+
+DynamicDataSink::UnownedResultOf::ReadAsset DynamicDataSink::Call::ReadAsset(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadAsset(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(asset), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DynamicDataSink::ReadAssetResponse> DynamicDataSink::InPlace::ReadAsset(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAssetRequest> params, ::fidl::BytePart response_buffer) {
+ DynamicDataSink::SetTransactionHeaderFor::ReadAssetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::ReadAssetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadAssetRequest, ReadAssetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::ReadAssetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DynamicDataSink::ResultOf::WriteAsset_Impl<DynamicDataSink::WriteAssetResponse>::WriteAsset_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAssetRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WriteAssetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteAssetRequest*>(_write_bytes);
+ _request.configuration = std::move(configuration);
+ _request.asset = std::move(asset);
+ _request.payload = std::move(payload);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteAssetRequest));
+ ::fidl::DecodedMessage<WriteAssetRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WriteAsset(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DynamicDataSink::ResultOf::WriteAsset DynamicDataSink::SyncClient::WriteAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteAsset(::zx::unowned_channel(this->channel_), std::move(configuration), std::move(asset), std::move(payload));
+}
+
+DynamicDataSink::ResultOf::WriteAsset DynamicDataSink::Call::WriteAsset(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteAsset(std::move(_client_end), std::move(configuration), std::move(asset), std::move(payload));
+}
+
+template <>
+DynamicDataSink::UnownedResultOf::WriteAsset_Impl<DynamicDataSink::WriteAssetResponse>::WriteAsset_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteAssetRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteAssetResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WriteAssetRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteAssetRequest*>(_request_buffer.data());
+ _request.configuration = std::move(configuration);
+ _request.asset = std::move(asset);
+ _request.payload = std::move(payload);
+ _request_buffer.set_actual(sizeof(WriteAssetRequest));
+ ::fidl::DecodedMessage<WriteAssetRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WriteAsset(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DynamicDataSink::UnownedResultOf::WriteAsset DynamicDataSink::SyncClient::WriteAsset(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAsset(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(configuration), std::move(asset), std::move(payload), std::move(_response_buffer));
+}
+
+DynamicDataSink::UnownedResultOf::WriteAsset DynamicDataSink::Call::WriteAsset(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteAsset(std::move(_client_end), std::move(_request_buffer), std::move(configuration), std::move(asset), std::move(payload), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DynamicDataSink::WriteAssetResponse> DynamicDataSink::InPlace::WriteAsset(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAssetRequest> params, ::fidl::BytePart response_buffer) {
+ DynamicDataSink::SetTransactionHeaderFor::WriteAssetRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WriteAssetResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteAssetRequest, WriteAssetResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WriteAssetResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DynamicDataSink::ResultOf::WriteVolumes_Impl<DynamicDataSink::WriteVolumesResponse>::WriteVolumes_Impl(::zx::unowned_channel _client_end, ::zx::channel payload) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteVolumesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WriteVolumesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteVolumesRequest*>(_write_bytes);
+ _request.payload = std::move(payload);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteVolumesRequest));
+ ::fidl::DecodedMessage<WriteVolumesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WriteVolumes(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DynamicDataSink::ResultOf::WriteVolumes DynamicDataSink::SyncClient::WriteVolumes(::zx::channel payload) {
+ return ResultOf::WriteVolumes(::zx::unowned_channel(this->channel_), std::move(payload));
+}
+
+DynamicDataSink::ResultOf::WriteVolumes DynamicDataSink::Call::WriteVolumes(::zx::unowned_channel _client_end, ::zx::channel payload) {
+ return ResultOf::WriteVolumes(std::move(_client_end), std::move(payload));
+}
+
+template <>
+DynamicDataSink::UnownedResultOf::WriteVolumes_Impl<DynamicDataSink::WriteVolumesResponse>::WriteVolumes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteVolumesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteVolumesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WriteVolumesRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteVolumesRequest*>(_request_buffer.data());
+ _request.payload = std::move(payload);
+ _request_buffer.set_actual(sizeof(WriteVolumesRequest));
+ ::fidl::DecodedMessage<WriteVolumesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WriteVolumes(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DynamicDataSink::UnownedResultOf::WriteVolumes DynamicDataSink::SyncClient::WriteVolumes(::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteVolumes(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(payload), std::move(_response_buffer));
+}
+
+DynamicDataSink::UnownedResultOf::WriteVolumes DynamicDataSink::Call::WriteVolumes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteVolumes(std::move(_client_end), std::move(_request_buffer), std::move(payload), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DynamicDataSink::WriteVolumesResponse> DynamicDataSink::InPlace::WriteVolumes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteVolumesRequest> params, ::fidl::BytePart response_buffer) {
+ DynamicDataSink::SetTransactionHeaderFor::WriteVolumesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WriteVolumesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteVolumesRequest, WriteVolumesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WriteVolumesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DynamicDataSink::ResultOf::WriteBootloader_Impl<DynamicDataSink::WriteBootloaderResponse>::WriteBootloader_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::mem::Buffer payload) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteBootloaderRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WriteBootloaderRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteBootloaderRequest*>(_write_bytes);
+ _request.payload = std::move(payload);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteBootloaderRequest));
+ ::fidl::DecodedMessage<WriteBootloaderRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WriteBootloader(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DynamicDataSink::ResultOf::WriteBootloader DynamicDataSink::SyncClient::WriteBootloader(::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteBootloader(::zx::unowned_channel(this->channel_), std::move(payload));
+}
+
+DynamicDataSink::ResultOf::WriteBootloader DynamicDataSink::Call::WriteBootloader(::zx::unowned_channel _client_end, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteBootloader(std::move(_client_end), std::move(payload));
+}
+
+template <>
+DynamicDataSink::UnownedResultOf::WriteBootloader_Impl<DynamicDataSink::WriteBootloaderResponse>::WriteBootloader_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteBootloaderRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteBootloaderResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WriteBootloaderRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WriteBootloaderRequest*>(_request_buffer.data());
+ _request.payload = std::move(payload);
+ _request_buffer.set_actual(sizeof(WriteBootloaderRequest));
+ ::fidl::DecodedMessage<WriteBootloaderRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WriteBootloader(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DynamicDataSink::UnownedResultOf::WriteBootloader DynamicDataSink::SyncClient::WriteBootloader(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteBootloader(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(payload), std::move(_response_buffer));
+}
+
+DynamicDataSink::UnownedResultOf::WriteBootloader DynamicDataSink::Call::WriteBootloader(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteBootloader(std::move(_client_end), std::move(_request_buffer), std::move(payload), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DynamicDataSink::WriteBootloaderResponse> DynamicDataSink::InPlace::WriteBootloader(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteBootloaderRequest> params, ::fidl::BytePart response_buffer) {
+ DynamicDataSink::SetTransactionHeaderFor::WriteBootloaderRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WriteBootloaderResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteBootloaderRequest, WriteBootloaderResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WriteBootloaderResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DynamicDataSink::ResultOf::WriteDataFile_Impl<DynamicDataSink::WriteDataFileResponse>::WriteDataFile_Impl(::zx::unowned_channel _client_end, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteDataFileRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ WriteDataFileRequest _request = {};
+ _request.filename = std::move(filename);
+ _request.payload = std::move(payload);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteDataFileRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DynamicDataSink::InPlace::WriteDataFile(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DynamicDataSink::ResultOf::WriteDataFile DynamicDataSink::SyncClient::WriteDataFile(::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteDataFile(::zx::unowned_channel(this->channel_), std::move(filename), std::move(payload));
+}
+
+DynamicDataSink::ResultOf::WriteDataFile DynamicDataSink::Call::WriteDataFile(::zx::unowned_channel _client_end, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload) {
+ return ResultOf::WriteDataFile(std::move(_client_end), std::move(filename), std::move(payload));
+}
+
+template <>
+DynamicDataSink::UnownedResultOf::WriteDataFile_Impl<DynamicDataSink::WriteDataFileResponse>::WriteDataFile_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WriteDataFileRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WriteDataFileResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ WriteDataFileRequest _request = {};
+ _request.filename = std::move(filename);
+ _request.payload = std::move(payload);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<WriteDataFileRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DynamicDataSink::InPlace::WriteDataFile(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DynamicDataSink::UnownedResultOf::WriteDataFile DynamicDataSink::SyncClient::WriteDataFile(::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteDataFile(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(filename), std::move(payload), std::move(_response_buffer));
+}
+
+DynamicDataSink::UnownedResultOf::WriteDataFile DynamicDataSink::Call::WriteDataFile(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WriteDataFile(std::move(_client_end), std::move(_request_buffer), std::move(filename), std::move(payload), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DynamicDataSink::WriteDataFileResponse> DynamicDataSink::InPlace::WriteDataFile(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteDataFileRequest> params, ::fidl::BytePart response_buffer) {
+ DynamicDataSink::SetTransactionHeaderFor::WriteDataFileRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WriteDataFileResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WriteDataFileRequest, WriteDataFileResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WriteDataFileResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DynamicDataSink::ResultOf::WipeVolume_Impl<DynamicDataSink::WipeVolumeResponse>::WipeVolume_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WipeVolumeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WipeVolumeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WipeVolumeRequest));
+ ::fidl::DecodedMessage<WipeVolumeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WipeVolume(std::move(_client_end), Super::response_buffer()));
+}
+
+DynamicDataSink::ResultOf::WipeVolume DynamicDataSink::SyncClient::WipeVolume() {
+ return ResultOf::WipeVolume(::zx::unowned_channel(this->channel_));
+}
+
+DynamicDataSink::ResultOf::WipeVolume DynamicDataSink::Call::WipeVolume(::zx::unowned_channel _client_end) {
+ return ResultOf::WipeVolume(std::move(_client_end));
+}
+
+template <>
+DynamicDataSink::UnownedResultOf::WipeVolume_Impl<DynamicDataSink::WipeVolumeResponse>::WipeVolume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WipeVolumeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WipeVolumeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WipeVolumeRequest));
+ ::fidl::DecodedMessage<WipeVolumeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WipeVolume(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DynamicDataSink::UnownedResultOf::WipeVolume DynamicDataSink::SyncClient::WipeVolume(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WipeVolume(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DynamicDataSink::UnownedResultOf::WipeVolume DynamicDataSink::Call::WipeVolume(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WipeVolume(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DynamicDataSink::WipeVolumeResponse> DynamicDataSink::InPlace::WipeVolume(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WipeVolumeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WipeVolumeRequest> params(std::move(_request_buffer));
+ DynamicDataSink::SetTransactionHeaderFor::WipeVolumeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WipeVolumeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WipeVolumeRequest, WipeVolumeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WipeVolumeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DynamicDataSink::ResultOf::InitializePartitionTables_Impl<DynamicDataSink::InitializePartitionTablesResponse>::InitializePartitionTables_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InitializePartitionTablesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, InitializePartitionTablesRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(InitializePartitionTablesRequest));
+ ::fidl::DecodedMessage<InitializePartitionTablesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DynamicDataSink::InPlace::InitializePartitionTables(std::move(_client_end), Super::response_buffer()));
+}
+
+DynamicDataSink::ResultOf::InitializePartitionTables DynamicDataSink::SyncClient::InitializePartitionTables() {
+ return ResultOf::InitializePartitionTables(::zx::unowned_channel(this->channel_));
+}
+
+DynamicDataSink::ResultOf::InitializePartitionTables DynamicDataSink::Call::InitializePartitionTables(::zx::unowned_channel _client_end) {
+ return ResultOf::InitializePartitionTables(std::move(_client_end));
+}
+
+template <>
+DynamicDataSink::UnownedResultOf::InitializePartitionTables_Impl<DynamicDataSink::InitializePartitionTablesResponse>::InitializePartitionTables_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(InitializePartitionTablesRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, InitializePartitionTablesRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(InitializePartitionTablesRequest));
+ ::fidl::DecodedMessage<InitializePartitionTablesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DynamicDataSink::InPlace::InitializePartitionTables(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DynamicDataSink::UnownedResultOf::InitializePartitionTables DynamicDataSink::SyncClient::InitializePartitionTables(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::InitializePartitionTables(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DynamicDataSink::UnownedResultOf::InitializePartitionTables DynamicDataSink::Call::InitializePartitionTables(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::InitializePartitionTables(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DynamicDataSink::InitializePartitionTablesResponse> DynamicDataSink::InPlace::InitializePartitionTables(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(InitializePartitionTablesRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<InitializePartitionTablesRequest> params(std::move(_request_buffer));
+ DynamicDataSink::SetTransactionHeaderFor::InitializePartitionTablesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::InitializePartitionTablesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<InitializePartitionTablesRequest, InitializePartitionTablesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::InitializePartitionTablesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DynamicDataSink::ResultOf::WipePartitionTables_Impl<DynamicDataSink::WipePartitionTablesResponse>::WipePartitionTables_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WipePartitionTablesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WipePartitionTablesRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WipePartitionTablesRequest));
+ ::fidl::DecodedMessage<WipePartitionTablesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WipePartitionTables(std::move(_client_end), Super::response_buffer()));
+}
+
+DynamicDataSink::ResultOf::WipePartitionTables DynamicDataSink::SyncClient::WipePartitionTables() {
+ return ResultOf::WipePartitionTables(::zx::unowned_channel(this->channel_));
+}
+
+DynamicDataSink::ResultOf::WipePartitionTables DynamicDataSink::Call::WipePartitionTables(::zx::unowned_channel _client_end) {
+ return ResultOf::WipePartitionTables(std::move(_client_end));
+}
+
+template <>
+DynamicDataSink::UnownedResultOf::WipePartitionTables_Impl<DynamicDataSink::WipePartitionTablesResponse>::WipePartitionTables_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WipePartitionTablesRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WipePartitionTablesRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WipePartitionTablesRequest));
+ ::fidl::DecodedMessage<WipePartitionTablesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DynamicDataSink::InPlace::WipePartitionTables(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DynamicDataSink::UnownedResultOf::WipePartitionTables DynamicDataSink::SyncClient::WipePartitionTables(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WipePartitionTables(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DynamicDataSink::UnownedResultOf::WipePartitionTables DynamicDataSink::Call::WipePartitionTables(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WipePartitionTables(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DynamicDataSink::WipePartitionTablesResponse> DynamicDataSink::InPlace::WipePartitionTables(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WipePartitionTablesRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WipePartitionTablesRequest> params(std::move(_request_buffer));
+ DynamicDataSink::SetTransactionHeaderFor::WipePartitionTablesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WipePartitionTablesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WipePartitionTablesRequest, WipePartitionTablesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DynamicDataSink::WipePartitionTablesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool DynamicDataSink::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDynamicDataSink_ReadAsset_Ordinal:
+ case kDynamicDataSink_ReadAsset_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadAssetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ReadAsset(std::move(message->configuration), std::move(message->asset),
+ Interface::ReadAssetCompleter::Sync(txn));
+ return true;
+ }
+ case kDynamicDataSink_WriteAsset_Ordinal:
+ case kDynamicDataSink_WriteAsset_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteAssetRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteAsset(std::move(message->configuration), std::move(message->asset), std::move(message->payload),
+ Interface::WriteAssetCompleter::Sync(txn));
+ return true;
+ }
+ case kDynamicDataSink_WriteVolumes_Ordinal:
+ case kDynamicDataSink_WriteVolumes_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteVolumesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteVolumes(std::move(message->payload),
+ Interface::WriteVolumesCompleter::Sync(txn));
+ return true;
+ }
+ case kDynamicDataSink_WriteBootloader_Ordinal:
+ case kDynamicDataSink_WriteBootloader_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteBootloaderRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteBootloader(std::move(message->payload),
+ Interface::WriteBootloaderCompleter::Sync(txn));
+ return true;
+ }
+ case kDynamicDataSink_WriteDataFile_Ordinal:
+ case kDynamicDataSink_WriteDataFile_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WriteDataFileRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WriteDataFile(std::move(message->filename), std::move(message->payload),
+ Interface::WriteDataFileCompleter::Sync(txn));
+ return true;
+ }
+ case kDynamicDataSink_WipeVolume_Ordinal:
+ case kDynamicDataSink_WipeVolume_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WipeVolumeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WipeVolume(
+ Interface::WipeVolumeCompleter::Sync(txn));
+ return true;
+ }
+ case kDynamicDataSink_InitializePartitionTables_Ordinal:
+ case kDynamicDataSink_InitializePartitionTables_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<InitializePartitionTablesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->InitializePartitionTables(
+ Interface::InitializePartitionTablesCompleter::Sync(txn));
+ return true;
+ }
+ case kDynamicDataSink_WipePartitionTables_Ordinal:
+ case kDynamicDataSink_WipePartitionTables_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WipePartitionTablesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WipePartitionTables(
+ Interface::WipePartitionTablesCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DynamicDataSink::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DynamicDataSink::Interface::ReadAssetCompleterBase::Reply(::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadAssetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ReadAssetResponse _response = {};
+ DynamicDataSink::SetTransactionHeaderFor::ReadAssetResponse(
+ ::fidl::DecodedMessage<ReadAssetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAssetResponse::PrimarySize,
+ ReadAssetResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DynamicDataSink::Interface::ReadAssetCompleterBase::ReplySuccess(::llcpp::fuchsia::mem::Buffer asset) {
+ DataSink_ReadAsset_Response response;
+ response.asset = std::move(asset);
+
+ Reply(DataSink_ReadAsset_Result::WithResponse(&response));
+}
+void DynamicDataSink::Interface::ReadAssetCompleterBase::ReplyError(int32_t error) {
+ Reply(DataSink_ReadAsset_Result::WithErr(&error));
+}
+
+void DynamicDataSink::Interface::ReadAssetCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result) {
+ if (_buffer.capacity() < ReadAssetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadAssetResponse _response = {};
+ DynamicDataSink::SetTransactionHeaderFor::ReadAssetResponse(
+ ::fidl::DecodedMessage<ReadAssetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadAssetResponse::PrimarySize,
+ ReadAssetResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DynamicDataSink::Interface::ReadAssetCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::mem::Buffer asset) {
+ DataSink_ReadAsset_Response response;
+ response.asset = std::move(asset);
+
+ Reply(std::move(_buffer), DataSink_ReadAsset_Result::WithResponse(&response));
+}
+
+void DynamicDataSink::Interface::ReadAssetCompleterBase::Reply(::fidl::DecodedMessage<ReadAssetResponse> params) {
+ DynamicDataSink::SetTransactionHeaderFor::ReadAssetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DynamicDataSink::Interface::WriteAssetCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteAssetResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteAssetResponse*>(_write_bytes);
+ DynamicDataSink::SetTransactionHeaderFor::WriteAssetResponse(
+ ::fidl::DecodedMessage<WriteAssetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAssetResponse::PrimarySize,
+ WriteAssetResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteAssetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteAssetResponse>(std::move(_response_bytes)));
+}
+
+void DynamicDataSink::Interface::WriteAssetCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WriteAssetResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteAssetResponse*>(_buffer.data());
+ DynamicDataSink::SetTransactionHeaderFor::WriteAssetResponse(
+ ::fidl::DecodedMessage<WriteAssetResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteAssetResponse::PrimarySize,
+ WriteAssetResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WriteAssetResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteAssetResponse>(std::move(_buffer)));
+}
+
+void DynamicDataSink::Interface::WriteAssetCompleterBase::Reply(::fidl::DecodedMessage<WriteAssetResponse> params) {
+ DynamicDataSink::SetTransactionHeaderFor::WriteAssetResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DynamicDataSink::Interface::WriteVolumesCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteVolumesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteVolumesResponse*>(_write_bytes);
+ DynamicDataSink::SetTransactionHeaderFor::WriteVolumesResponse(
+ ::fidl::DecodedMessage<WriteVolumesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteVolumesResponse::PrimarySize,
+ WriteVolumesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteVolumesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteVolumesResponse>(std::move(_response_bytes)));
+}
+
+void DynamicDataSink::Interface::WriteVolumesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WriteVolumesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteVolumesResponse*>(_buffer.data());
+ DynamicDataSink::SetTransactionHeaderFor::WriteVolumesResponse(
+ ::fidl::DecodedMessage<WriteVolumesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteVolumesResponse::PrimarySize,
+ WriteVolumesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WriteVolumesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteVolumesResponse>(std::move(_buffer)));
+}
+
+void DynamicDataSink::Interface::WriteVolumesCompleterBase::Reply(::fidl::DecodedMessage<WriteVolumesResponse> params) {
+ DynamicDataSink::SetTransactionHeaderFor::WriteVolumesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DynamicDataSink::Interface::WriteBootloaderCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteBootloaderResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteBootloaderResponse*>(_write_bytes);
+ DynamicDataSink::SetTransactionHeaderFor::WriteBootloaderResponse(
+ ::fidl::DecodedMessage<WriteBootloaderResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteBootloaderResponse::PrimarySize,
+ WriteBootloaderResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteBootloaderResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteBootloaderResponse>(std::move(_response_bytes)));
+}
+
+void DynamicDataSink::Interface::WriteBootloaderCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WriteBootloaderResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteBootloaderResponse*>(_buffer.data());
+ DynamicDataSink::SetTransactionHeaderFor::WriteBootloaderResponse(
+ ::fidl::DecodedMessage<WriteBootloaderResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteBootloaderResponse::PrimarySize,
+ WriteBootloaderResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WriteBootloaderResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteBootloaderResponse>(std::move(_buffer)));
+}
+
+void DynamicDataSink::Interface::WriteBootloaderCompleterBase::Reply(::fidl::DecodedMessage<WriteBootloaderResponse> params) {
+ DynamicDataSink::SetTransactionHeaderFor::WriteBootloaderResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DynamicDataSink::Interface::WriteDataFileCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WriteDataFileResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WriteDataFileResponse*>(_write_bytes);
+ DynamicDataSink::SetTransactionHeaderFor::WriteDataFileResponse(
+ ::fidl::DecodedMessage<WriteDataFileResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteDataFileResponse::PrimarySize,
+ WriteDataFileResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WriteDataFileResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteDataFileResponse>(std::move(_response_bytes)));
+}
+
+void DynamicDataSink::Interface::WriteDataFileCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WriteDataFileResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WriteDataFileResponse*>(_buffer.data());
+ DynamicDataSink::SetTransactionHeaderFor::WriteDataFileResponse(
+ ::fidl::DecodedMessage<WriteDataFileResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WriteDataFileResponse::PrimarySize,
+ WriteDataFileResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WriteDataFileResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WriteDataFileResponse>(std::move(_buffer)));
+}
+
+void DynamicDataSink::Interface::WriteDataFileCompleterBase::Reply(::fidl::DecodedMessage<WriteDataFileResponse> params) {
+ DynamicDataSink::SetTransactionHeaderFor::WriteDataFileResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DynamicDataSink::Interface::WipeVolumeCompleterBase::Reply(::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WipeVolumeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ WipeVolumeResponse _response = {};
+ DynamicDataSink::SetTransactionHeaderFor::WipeVolumeResponse(
+ ::fidl::DecodedMessage<WipeVolumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WipeVolumeResponse::PrimarySize,
+ WipeVolumeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DynamicDataSink::Interface::WipeVolumeCompleterBase::ReplySuccess(::zx::channel volume) {
+ DataSink_WipeVolume_Response response;
+ response.volume = std::move(volume);
+
+ Reply(DataSink_WipeVolume_Result::WithResponse(&response));
+}
+void DynamicDataSink::Interface::WipeVolumeCompleterBase::ReplyError(int32_t error) {
+ Reply(DataSink_WipeVolume_Result::WithErr(&error));
+}
+
+void DynamicDataSink::Interface::WipeVolumeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result) {
+ if (_buffer.capacity() < WipeVolumeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ WipeVolumeResponse _response = {};
+ DynamicDataSink::SetTransactionHeaderFor::WipeVolumeResponse(
+ ::fidl::DecodedMessage<WipeVolumeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WipeVolumeResponse::PrimarySize,
+ WipeVolumeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DynamicDataSink::Interface::WipeVolumeCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::channel volume) {
+ DataSink_WipeVolume_Response response;
+ response.volume = std::move(volume);
+
+ Reply(std::move(_buffer), DataSink_WipeVolume_Result::WithResponse(&response));
+}
+
+void DynamicDataSink::Interface::WipeVolumeCompleterBase::Reply(::fidl::DecodedMessage<WipeVolumeResponse> params) {
+ DynamicDataSink::SetTransactionHeaderFor::WipeVolumeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DynamicDataSink::Interface::InitializePartitionTablesCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InitializePartitionTablesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<InitializePartitionTablesResponse*>(_write_bytes);
+ DynamicDataSink::SetTransactionHeaderFor::InitializePartitionTablesResponse(
+ ::fidl::DecodedMessage<InitializePartitionTablesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InitializePartitionTablesResponse::PrimarySize,
+ InitializePartitionTablesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(InitializePartitionTablesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<InitializePartitionTablesResponse>(std::move(_response_bytes)));
+}
+
+void DynamicDataSink::Interface::InitializePartitionTablesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < InitializePartitionTablesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<InitializePartitionTablesResponse*>(_buffer.data());
+ DynamicDataSink::SetTransactionHeaderFor::InitializePartitionTablesResponse(
+ ::fidl::DecodedMessage<InitializePartitionTablesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InitializePartitionTablesResponse::PrimarySize,
+ InitializePartitionTablesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(InitializePartitionTablesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<InitializePartitionTablesResponse>(std::move(_buffer)));
+}
+
+void DynamicDataSink::Interface::InitializePartitionTablesCompleterBase::Reply(::fidl::DecodedMessage<InitializePartitionTablesResponse> params) {
+ DynamicDataSink::SetTransactionHeaderFor::InitializePartitionTablesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DynamicDataSink::Interface::WipePartitionTablesCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WipePartitionTablesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WipePartitionTablesResponse*>(_write_bytes);
+ DynamicDataSink::SetTransactionHeaderFor::WipePartitionTablesResponse(
+ ::fidl::DecodedMessage<WipePartitionTablesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WipePartitionTablesResponse::PrimarySize,
+ WipePartitionTablesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WipePartitionTablesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WipePartitionTablesResponse>(std::move(_response_bytes)));
+}
+
+void DynamicDataSink::Interface::WipePartitionTablesCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < WipePartitionTablesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WipePartitionTablesResponse*>(_buffer.data());
+ DynamicDataSink::SetTransactionHeaderFor::WipePartitionTablesResponse(
+ ::fidl::DecodedMessage<WipePartitionTablesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WipePartitionTablesResponse::PrimarySize,
+ WipePartitionTablesResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(WipePartitionTablesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WipePartitionTablesResponse>(std::move(_buffer)));
+}
+
+void DynamicDataSink::Interface::WipePartitionTablesCompleterBase::Reply(::fidl::DecodedMessage<WipePartitionTablesResponse> params) {
+ DynamicDataSink::SetTransactionHeaderFor::WipePartitionTablesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DynamicDataSink::SetTransactionHeaderFor::ReadAssetRequest(const ::fidl::DecodedMessage<DynamicDataSink::ReadAssetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_ReadAsset_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DynamicDataSink::SetTransactionHeaderFor::ReadAssetResponse(const ::fidl::DecodedMessage<DynamicDataSink::ReadAssetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_ReadAsset_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DynamicDataSink::SetTransactionHeaderFor::WriteAssetRequest(const ::fidl::DecodedMessage<DynamicDataSink::WriteAssetRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WriteAsset_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DynamicDataSink::SetTransactionHeaderFor::WriteAssetResponse(const ::fidl::DecodedMessage<DynamicDataSink::WriteAssetResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WriteAsset_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DynamicDataSink::SetTransactionHeaderFor::WriteVolumesRequest(const ::fidl::DecodedMessage<DynamicDataSink::WriteVolumesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WriteVolumes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DynamicDataSink::SetTransactionHeaderFor::WriteVolumesResponse(const ::fidl::DecodedMessage<DynamicDataSink::WriteVolumesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WriteVolumes_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DynamicDataSink::SetTransactionHeaderFor::WriteBootloaderRequest(const ::fidl::DecodedMessage<DynamicDataSink::WriteBootloaderRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WriteBootloader_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DynamicDataSink::SetTransactionHeaderFor::WriteBootloaderResponse(const ::fidl::DecodedMessage<DynamicDataSink::WriteBootloaderResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WriteBootloader_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DynamicDataSink::SetTransactionHeaderFor::WriteDataFileRequest(const ::fidl::DecodedMessage<DynamicDataSink::WriteDataFileRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WriteDataFile_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DynamicDataSink::SetTransactionHeaderFor::WriteDataFileResponse(const ::fidl::DecodedMessage<DynamicDataSink::WriteDataFileResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WriteDataFile_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DynamicDataSink::SetTransactionHeaderFor::WipeVolumeRequest(const ::fidl::DecodedMessage<DynamicDataSink::WipeVolumeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WipeVolume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DynamicDataSink::SetTransactionHeaderFor::WipeVolumeResponse(const ::fidl::DecodedMessage<DynamicDataSink::WipeVolumeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WipeVolume_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DynamicDataSink::SetTransactionHeaderFor::InitializePartitionTablesRequest(const ::fidl::DecodedMessage<DynamicDataSink::InitializePartitionTablesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_InitializePartitionTables_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DynamicDataSink::SetTransactionHeaderFor::InitializePartitionTablesResponse(const ::fidl::DecodedMessage<DynamicDataSink::InitializePartitionTablesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_InitializePartitionTables_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DynamicDataSink::SetTransactionHeaderFor::WipePartitionTablesRequest(const ::fidl::DecodedMessage<DynamicDataSink::WipePartitionTablesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WipePartitionTables_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DynamicDataSink::SetTransactionHeaderFor::WipePartitionTablesResponse(const ::fidl::DecodedMessage<DynamicDataSink::WipePartitionTablesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDynamicDataSink_WipePartitionTables_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace paver
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-paver/gen/llcpp/include/fuchsia/paver/llcpp/fidl.h b/zircon/system/fidl/fuchsia-paver/gen/llcpp/include/fuchsia/paver/llcpp/fidl.h
new file mode 100644
index 0000000..bc9b7f45
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-paver/gen/llcpp/include/fuchsia/paver/llcpp/fidl.h
@@ -0,0 +1,4170 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/hardware/block/llcpp/fidl.h>
+#include <fuchsia/hardware/block/volume/llcpp/fidl.h>
+#include <fuchsia/io/llcpp/fidl.h>
+#include <fuchsia/mem/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace paver {
+
+struct ReadInfo;
+struct ReadResult;
+class Paver;
+class PayloadStream;
+struct DataSink_WipeVolume_Response;
+struct DataSink_WipeVolume_Result;
+enum class ConfigurationStatus : uint32_t {
+ HEALTHY = 1u,
+ PENDING = 2u,
+ UNBOOTABLE = 3u,
+};
+
+
+struct BootManager_QueryConfigurationStatus_Response;
+struct BootManager_QueryConfigurationStatus_Result;
+enum class Configuration : uint32_t {
+ A = 1u,
+ B = 2u,
+ RECOVERY = 3u,
+};
+
+
+struct BootManager_QueryActiveConfiguration_Response;
+struct BootManager_QueryActiveConfiguration_Result;
+class BootManager;
+enum class Asset : uint32_t {
+ KERNEL = 1u,
+ VERIFIED_BOOT_METADATA = 2u,
+};
+
+
+struct DataSink_ReadAsset_Response;
+struct DataSink_ReadAsset_Result;
+class DataSink;
+class DynamicDataSink;
+
+extern "C" const fidl_type_t v1_fuchsia_paver_ReadResultTable;
+
+struct ReadResult {
+ ReadResult() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kErr = 1, // 0x1
+ kEof = 2, // 0x2
+ kInfo = 3, // 0x3
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static ReadResult WithErr(int32_t* val) {
+ ReadResult result;
+ result.set_err(val);
+ return result;
+ }
+
+ // Error encountered while reading data.
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Error encountered while reading data.
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+
+ bool is_eof() const { return ordinal() == Ordinal::kEof; }
+
+ static ReadResult WithEof(bool* val) {
+ ReadResult result;
+ result.set_eof(val);
+ return result;
+ }
+
+ // End of file reached.
+ void set_eof(bool* elem) {
+ ordinal_ = Ordinal::kEof;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // End of file reached.
+ bool& mutable_eof() {
+ ZX_ASSERT(ordinal() == Ordinal::kEof);
+ return *static_cast<bool*>(envelope_.data);
+ }
+ const bool& eof() const {
+ ZX_ASSERT(ordinal() == Ordinal::kEof);
+ return *static_cast<bool*>(envelope_.data);
+ }
+
+ bool is_info() const { return ordinal() == Ordinal::kInfo; }
+
+ static ReadResult WithInfo(::llcpp::fuchsia::paver::ReadInfo* val) {
+ ReadResult result;
+ result.set_info(val);
+ return result;
+ }
+
+ // Information about location of successfully read data within pre-registered VMO.
+ void set_info(::llcpp::fuchsia::paver::ReadInfo* elem) {
+ ordinal_ = Ordinal::kInfo;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ // Information about location of successfully read data within pre-registered VMO.
+ ::llcpp::fuchsia::paver::ReadInfo& mutable_info() {
+ ZX_ASSERT(ordinal() == Ordinal::kInfo);
+ return *static_cast<::llcpp::fuchsia::paver::ReadInfo*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::paver::ReadInfo& info() const {
+ ZX_ASSERT(ordinal() == Ordinal::kInfo);
+ return *static_cast<::llcpp::fuchsia::paver::ReadInfo*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_ReadResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kErr = 1, // 0x1
+ kEof = 2, // 0x2
+ kInfo = 3, // 0x3
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSink_WipeVolume_ResultTable;
+
+struct DataSink_WipeVolume_Result {
+ DataSink_WipeVolume_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static DataSink_WipeVolume_Result WithResponse(::llcpp::fuchsia::paver::DataSink_WipeVolume_Response* val) {
+ DataSink_WipeVolume_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::paver::DataSink_WipeVolume_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::paver::DataSink_WipeVolume_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::paver::DataSink_WipeVolume_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::paver::DataSink_WipeVolume_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::paver::DataSink_WipeVolume_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static DataSink_WipeVolume_Result WithErr(int32_t* val) {
+ DataSink_WipeVolume_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSink_WipeVolume_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManager_QueryConfigurationStatus_ResultTable;
+
+struct BootManager_QueryConfigurationStatus_Result {
+ BootManager_QueryConfigurationStatus_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static BootManager_QueryConfigurationStatus_Result WithResponse(::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response* val) {
+ BootManager_QueryConfigurationStatus_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static BootManager_QueryConfigurationStatus_Result WithErr(int32_t* val) {
+ BootManager_QueryConfigurationStatus_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManager_QueryConfigurationStatus_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManager_QueryActiveConfiguration_ResultTable;
+
+struct BootManager_QueryActiveConfiguration_Result {
+ BootManager_QueryActiveConfiguration_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static BootManager_QueryActiveConfiguration_Result WithResponse(::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response* val) {
+ BootManager_QueryActiveConfiguration_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static BootManager_QueryActiveConfiguration_Result WithErr(int32_t* val) {
+ BootManager_QueryActiveConfiguration_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManager_QueryActiveConfiguration_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSink_ReadAsset_ResultTable;
+
+struct DataSink_ReadAsset_Result {
+ DataSink_ReadAsset_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static DataSink_ReadAsset_Result WithResponse(::llcpp::fuchsia::paver::DataSink_ReadAsset_Response* val) {
+ DataSink_ReadAsset_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::paver::DataSink_ReadAsset_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::paver::DataSink_ReadAsset_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::paver::DataSink_ReadAsset_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::paver::DataSink_ReadAsset_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::paver::DataSink_ReadAsset_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static DataSink_ReadAsset_Result WithErr(int32_t* val) {
+ DataSink_ReadAsset_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSink_ReadAsset_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_ReadInfoTable;
+
+struct ReadInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_ReadInfoTable;
+ 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;
+
+ // Offset into VMO where read data starts.
+ uint64_t offset = {};
+
+ // Size of read data.
+ uint64_t size = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverFindDataSinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverFindDataSinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverUseBlockDeviceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverUseBlockDeviceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverFindBootManagerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PaverFindBootManagerResponseTable;
+
+class Paver final {
+ Paver() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.paver.Paver";
+
+ struct FindDataSinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel data_sink;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_PaverFindDataSinkRequestTable;
+ 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;
+ };
+
+ struct UseBlockDeviceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel block_device;
+ ::zx::channel data_sink;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_PaverUseBlockDeviceRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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;
+ };
+
+ struct FindBootManagerRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel boot_manager;
+ bool initialize;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_PaverFindBootManagerRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class FindDataSink_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ FindDataSink_Impl(::zx::unowned_channel _client_end, ::zx::channel data_sink);
+ ~FindDataSink_Impl() = default;
+ FindDataSink_Impl(FindDataSink_Impl&& other) = default;
+ FindDataSink_Impl& operator=(FindDataSink_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class UseBlockDevice_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ UseBlockDevice_Impl(::zx::unowned_channel _client_end, ::zx::channel block_device, ::zx::channel data_sink);
+ ~UseBlockDevice_Impl() = default;
+ UseBlockDevice_Impl(UseBlockDevice_Impl&& other) = default;
+ UseBlockDevice_Impl& operator=(UseBlockDevice_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class FindBootManager_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ FindBootManager_Impl(::zx::unowned_channel _client_end, ::zx::channel boot_manager, bool initialize);
+ ~FindBootManager_Impl() = default;
+ FindBootManager_Impl(FindBootManager_Impl&& other) = default;
+ FindBootManager_Impl& operator=(FindBootManager_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using FindDataSink = FindDataSink_Impl;
+ using UseBlockDevice = UseBlockDevice_Impl;
+ using FindBootManager = FindBootManager_Impl;
+ };
+
+ // 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:
+ class FindDataSink_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ FindDataSink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel data_sink);
+ ~FindDataSink_Impl() = default;
+ FindDataSink_Impl(FindDataSink_Impl&& other) = default;
+ FindDataSink_Impl& operator=(FindDataSink_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class UseBlockDevice_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ UseBlockDevice_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel block_device, ::zx::channel data_sink);
+ ~UseBlockDevice_Impl() = default;
+ UseBlockDevice_Impl(UseBlockDevice_Impl&& other) = default;
+ UseBlockDevice_Impl& operator=(UseBlockDevice_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class FindBootManager_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ FindBootManager_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel boot_manager, bool initialize);
+ ~FindBootManager_Impl() = default;
+ FindBootManager_Impl(FindBootManager_Impl&& other) = default;
+ FindBootManager_Impl& operator=(FindBootManager_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using FindDataSink = FindDataSink_Impl;
+ using UseBlockDevice = UseBlockDevice_Impl;
+ using FindBootManager = FindBootManager_Impl;
+ };
+
+ 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_; }
+
+ // Attempts to auto-discover the data sink where assets and volumes will get paved to.
+ // On devices with GPT, the partition must have a valid FVM partition in order for
+ // auto-discovery to find it. If multiple devices are found suitable, error is returned.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::FindDataSink FindDataSink(::zx::channel data_sink);
+
+ // Attempts to auto-discover the data sink where assets and volumes will get paved to.
+ // On devices with GPT, the partition must have a valid FVM partition in order for
+ // auto-discovery to find it. If multiple devices are found suitable, error is returned.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::FindDataSink FindDataSink(::fidl::BytePart _request_buffer, ::zx::channel data_sink);
+
+ // Provide a block device to use as a data sink. Assets and volumes will be paved to
+ // partitions within this block device.
+ //
+ // It assumes that channel backing |block_device| also implements `fuchsia.io.Node` for now.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::UseBlockDevice UseBlockDevice(::zx::channel block_device, ::zx::channel data_sink);
+
+ // Provide a block device to use as a data sink. Assets and volumes will be paved to
+ // partitions within this block device.
+ //
+ // It assumes that channel backing |block_device| also implements `fuchsia.io.Node` for now.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::UseBlockDevice UseBlockDevice(::fidl::BytePart _request_buffer, ::zx::channel block_device, ::zx::channel data_sink);
+
+ // Attempts to auto-discover the boot manager.
+ //
+ // |initialize| should only be set to true to initialize ABR metadata for the first time
+ // (i.e. it should not be called every boot), or recover from corrupted ABR metadata.
+ //
+ // |boot_manager| will be closed on error, with an epitaph provided on failure reason.
+ // ZX_ERR_NOT_SUPPORTED indicates lack of support and configuration A is always booted from.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::FindBootManager FindBootManager(::zx::channel boot_manager, bool initialize);
+
+ // Attempts to auto-discover the boot manager.
+ //
+ // |initialize| should only be set to true to initialize ABR metadata for the first time
+ // (i.e. it should not be called every boot), or recover from corrupted ABR metadata.
+ //
+ // |boot_manager| will be closed on error, with an epitaph provided on failure reason.
+ // ZX_ERR_NOT_SUPPORTED indicates lack of support and configuration A is always booted from.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::FindBootManager FindBootManager(::fidl::BytePart _request_buffer, ::zx::channel boot_manager, bool initialize);
+
+ 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:
+
+ // Attempts to auto-discover the data sink where assets and volumes will get paved to.
+ // On devices with GPT, the partition must have a valid FVM partition in order for
+ // auto-discovery to find it. If multiple devices are found suitable, error is returned.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::FindDataSink FindDataSink(::zx::unowned_channel _client_end, ::zx::channel data_sink);
+
+ // Attempts to auto-discover the data sink where assets and volumes will get paved to.
+ // On devices with GPT, the partition must have a valid FVM partition in order for
+ // auto-discovery to find it. If multiple devices are found suitable, error is returned.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::FindDataSink FindDataSink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel data_sink);
+
+ // Provide a block device to use as a data sink. Assets and volumes will be paved to
+ // partitions within this block device.
+ //
+ // It assumes that channel backing |block_device| also implements `fuchsia.io.Node` for now.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::UseBlockDevice UseBlockDevice(::zx::unowned_channel _client_end, ::zx::channel block_device, ::zx::channel data_sink);
+
+ // Provide a block device to use as a data sink. Assets and volumes will be paved to
+ // partitions within this block device.
+ //
+ // It assumes that channel backing |block_device| also implements `fuchsia.io.Node` for now.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::UseBlockDevice UseBlockDevice(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel block_device, ::zx::channel data_sink);
+
+ // Attempts to auto-discover the boot manager.
+ //
+ // |initialize| should only be set to true to initialize ABR metadata for the first time
+ // (i.e. it should not be called every boot), or recover from corrupted ABR metadata.
+ //
+ // |boot_manager| will be closed on error, with an epitaph provided on failure reason.
+ // ZX_ERR_NOT_SUPPORTED indicates lack of support and configuration A is always booted from.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::FindBootManager FindBootManager(::zx::unowned_channel _client_end, ::zx::channel boot_manager, bool initialize);
+
+ // Attempts to auto-discover the boot manager.
+ //
+ // |initialize| should only be set to true to initialize ABR metadata for the first time
+ // (i.e. it should not be called every boot), or recover from corrupted ABR metadata.
+ //
+ // |boot_manager| will be closed on error, with an epitaph provided on failure reason.
+ // ZX_ERR_NOT_SUPPORTED indicates lack of support and configuration A is always booted from.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::FindBootManager FindBootManager(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel boot_manager, bool initialize);
+
+ };
+
+ // 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:
+
+ // Attempts to auto-discover the data sink where assets and volumes will get paved to.
+ // On devices with GPT, the partition must have a valid FVM partition in order for
+ // auto-discovery to find it. If multiple devices are found suitable, error is returned.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ static ::fidl::internal::StatusAndError FindDataSink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<FindDataSinkRequest> params);
+
+ // Provide a block device to use as a data sink. Assets and volumes will be paved to
+ // partitions within this block device.
+ //
+ // It assumes that channel backing |block_device| also implements `fuchsia.io.Node` for now.
+ //
+ // |data_sink| will be closed on error, with an epitaph provided on failure reason.
+ static ::fidl::internal::StatusAndError UseBlockDevice(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<UseBlockDeviceRequest> params);
+
+ // Attempts to auto-discover the boot manager.
+ //
+ // |initialize| should only be set to true to initialize ABR metadata for the first time
+ // (i.e. it should not be called every boot), or recover from corrupted ABR metadata.
+ //
+ // |boot_manager| will be closed on error, with an epitaph provided on failure reason.
+ // ZX_ERR_NOT_SUPPORTED indicates lack of support and configuration A is always booted from.
+ static ::fidl::internal::StatusAndError FindBootManager(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<FindBootManagerRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Paver;
+ using _Base = ::fidl::CompleterBase;
+
+ using FindDataSinkCompleter = ::fidl::Completer<>;
+
+ virtual void FindDataSink(::zx::channel data_sink, FindDataSinkCompleter::Sync _completer) = 0;
+
+ using UseBlockDeviceCompleter = ::fidl::Completer<>;
+
+ virtual void UseBlockDevice(::zx::channel block_device, ::zx::channel data_sink, UseBlockDeviceCompleter::Sync _completer) = 0;
+
+ using FindBootManagerCompleter = ::fidl::Completer<>;
+
+ virtual void FindBootManager(::zx::channel boot_manager, bool initialize, FindBootManagerCompleter::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 FindDataSinkRequest(const ::fidl::DecodedMessage<Paver::FindDataSinkRequest>& _msg);
+ static void UseBlockDeviceRequest(const ::fidl::DecodedMessage<Paver::UseBlockDeviceRequest>& _msg);
+ static void FindBootManagerRequest(const ::fidl::DecodedMessage<Paver::FindBootManagerRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_PayloadStreamRegisterVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PayloadStreamRegisterVmoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PayloadStreamReadDataRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_PayloadStreamReadDataResponseTable;
+
+// Protocol for streaming the FVM payload.
+class PayloadStream final {
+ PayloadStream() = delete;
+ public:
+
+ struct RegisterVmoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_PayloadStreamRegisterVmoResponseTable;
+ 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 RegisterVmoRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo vmo;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_PayloadStreamRegisterVmoRequestTable;
+ 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 = RegisterVmoResponse;
+ };
+
+ struct ReadDataResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::ReadResult result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_PayloadStreamReadDataResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using ReadDataRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class RegisterVmo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RegisterVmo_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo);
+ ~RegisterVmo_Impl() = default;
+ RegisterVmo_Impl(RegisterVmo_Impl&& other) = default;
+ RegisterVmo_Impl& operator=(RegisterVmo_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 ReadData_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadData_Impl(::zx::unowned_channel _client_end);
+ ~ReadData_Impl() = default;
+ ReadData_Impl(ReadData_Impl&& other) = default;
+ ReadData_Impl& operator=(ReadData_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 RegisterVmo = RegisterVmo_Impl<RegisterVmoResponse>;
+ using ReadData = ReadData_Impl<ReadDataResponse>;
+ };
+
+ // 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 RegisterVmo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RegisterVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer);
+ ~RegisterVmo_Impl() = default;
+ RegisterVmo_Impl(RegisterVmo_Impl&& other) = default;
+ RegisterVmo_Impl& operator=(RegisterVmo_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 ReadData_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadData_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ReadData_Impl() = default;
+ ReadData_Impl(ReadData_Impl&& other) = default;
+ ReadData_Impl& operator=(ReadData_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 RegisterVmo = RegisterVmo_Impl<RegisterVmoResponse>;
+ using ReadData = ReadData_Impl<ReadDataResponse>;
+ };
+
+ 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_; }
+
+ // Registers a VMO to stream into.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RegisterVmo RegisterVmo(::zx::vmo vmo);
+
+ // Registers a VMO to stream into.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RegisterVmo RegisterVmo(::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer);
+
+ // Reads data into the pre-registered vmo.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReadData ReadData();
+
+ // Reads data into the pre-registered vmo.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadData ReadData(::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:
+
+ // Registers a VMO to stream into.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RegisterVmo RegisterVmo(::zx::unowned_channel _client_end, ::zx::vmo vmo);
+
+ // Registers a VMO to stream into.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RegisterVmo RegisterVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer);
+
+ // Reads data into the pre-registered vmo.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReadData ReadData(::zx::unowned_channel _client_end);
+
+ // Reads data into the pre-registered vmo.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadData ReadData(::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:
+
+ // Registers a VMO to stream into.
+ static ::fidl::DecodeResult<RegisterVmoResponse> RegisterVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RegisterVmoRequest> params, ::fidl::BytePart response_buffer);
+
+ // Reads data into the pre-registered vmo.
+ static ::fidl::DecodeResult<ReadDataResponse> ReadData(::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 = PayloadStream;
+ using _Base = ::fidl::CompleterBase;
+
+ class RegisterVmoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<RegisterVmoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RegisterVmoCompleter = ::fidl::Completer<RegisterVmoCompleterBase>;
+
+ virtual void RegisterVmo(::zx::vmo vmo, RegisterVmoCompleter::Sync _completer) = 0;
+
+ class ReadDataCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::paver::ReadResult result);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::ReadResult result);
+ void Reply(::fidl::DecodedMessage<ReadDataResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadDataCompleter = ::fidl::Completer<ReadDataCompleterBase>;
+
+ virtual void ReadData(ReadDataCompleter::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 RegisterVmoRequest(const ::fidl::DecodedMessage<PayloadStream::RegisterVmoRequest>& _msg);
+ static void RegisterVmoResponse(const ::fidl::DecodedMessage<PayloadStream::RegisterVmoResponse>& _msg);
+ static void ReadDataRequest(const ::fidl::DecodedMessage<PayloadStream::ReadDataRequest>& _msg);
+ static void ReadDataResponse(const ::fidl::DecodedMessage<PayloadStream::ReadDataResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSink_WipeVolume_ResponseTable;
+
+struct DataSink_WipeVolume_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSink_WipeVolume_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::channel volume = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManager_QueryConfigurationStatus_ResponseTable;
+
+struct BootManager_QueryConfigurationStatus_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManager_QueryConfigurationStatus_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::paver::ConfigurationStatus status = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManager_QueryActiveConfiguration_ResponseTable;
+
+struct BootManager_QueryActiveConfiguration_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManager_QueryActiveConfiguration_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::paver::Configuration configuration = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerQueryActiveConfigurationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerQueryActiveConfigurationResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerQueryConfigurationStatusRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerQueryConfigurationStatusResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetConfigurationActiveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetConfigurationActiveResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetConfigurationUnbootableRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetConfigurationUnbootableResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetActiveConfigurationHealthyRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_BootManagerSetActiveConfigurationHealthyResponseTable;
+
+// Protocol for managing boot configurations.
+class BootManager final {
+ BootManager() = delete;
+ public:
+
+ struct QueryActiveConfigurationResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManagerQueryActiveConfigurationResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using QueryActiveConfigurationRequest = ::fidl::AnyZeroArgMessage;
+
+ struct QueryConfigurationStatusResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManagerQueryConfigurationStatusResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct QueryConfigurationStatusRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::Configuration configuration;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManagerQueryConfigurationStatusRequestTable;
+ 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 = QueryConfigurationStatusResponse;
+ };
+
+ struct SetConfigurationActiveResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManagerSetConfigurationActiveResponseTable;
+ 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 SetConfigurationActiveRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::Configuration configuration;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManagerSetConfigurationActiveRequestTable;
+ 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 = SetConfigurationActiveResponse;
+ };
+
+ struct SetConfigurationUnbootableResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManagerSetConfigurationUnbootableResponseTable;
+ 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 SetConfigurationUnbootableRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::Configuration configuration;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManagerSetConfigurationUnbootableRequestTable;
+ 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 = SetConfigurationUnbootableResponse;
+ };
+
+ struct SetActiveConfigurationHealthyResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_BootManagerSetActiveConfigurationHealthyResponseTable;
+ 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 SetActiveConfigurationHealthyRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class QueryActiveConfiguration_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ QueryActiveConfiguration_Impl(::zx::unowned_channel _client_end);
+ ~QueryActiveConfiguration_Impl() = default;
+ QueryActiveConfiguration_Impl(QueryActiveConfiguration_Impl&& other) = default;
+ QueryActiveConfiguration_Impl& operator=(QueryActiveConfiguration_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 QueryConfigurationStatus_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ QueryConfigurationStatus_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration);
+ ~QueryConfigurationStatus_Impl() = default;
+ QueryConfigurationStatus_Impl(QueryConfigurationStatus_Impl&& other) = default;
+ QueryConfigurationStatus_Impl& operator=(QueryConfigurationStatus_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 SetConfigurationActive_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetConfigurationActive_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration);
+ ~SetConfigurationActive_Impl() = default;
+ SetConfigurationActive_Impl(SetConfigurationActive_Impl&& other) = default;
+ SetConfigurationActive_Impl& operator=(SetConfigurationActive_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 SetConfigurationUnbootable_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetConfigurationUnbootable_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration);
+ ~SetConfigurationUnbootable_Impl() = default;
+ SetConfigurationUnbootable_Impl(SetConfigurationUnbootable_Impl&& other) = default;
+ SetConfigurationUnbootable_Impl& operator=(SetConfigurationUnbootable_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 SetActiveConfigurationHealthy_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetActiveConfigurationHealthy_Impl(::zx::unowned_channel _client_end);
+ ~SetActiveConfigurationHealthy_Impl() = default;
+ SetActiveConfigurationHealthy_Impl(SetActiveConfigurationHealthy_Impl&& other) = default;
+ SetActiveConfigurationHealthy_Impl& operator=(SetActiveConfigurationHealthy_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 QueryActiveConfiguration = QueryActiveConfiguration_Impl<QueryActiveConfigurationResponse>;
+ using QueryConfigurationStatus = QueryConfigurationStatus_Impl<QueryConfigurationStatusResponse>;
+ using SetConfigurationActive = SetConfigurationActive_Impl<SetConfigurationActiveResponse>;
+ using SetConfigurationUnbootable = SetConfigurationUnbootable_Impl<SetConfigurationUnbootableResponse>;
+ using SetActiveConfigurationHealthy = SetActiveConfigurationHealthy_Impl<SetActiveConfigurationHealthyResponse>;
+ };
+
+ // 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 QueryActiveConfiguration_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ QueryActiveConfiguration_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~QueryActiveConfiguration_Impl() = default;
+ QueryActiveConfiguration_Impl(QueryActiveConfiguration_Impl&& other) = default;
+ QueryActiveConfiguration_Impl& operator=(QueryActiveConfiguration_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 QueryConfigurationStatus_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ QueryConfigurationStatus_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+ ~QueryConfigurationStatus_Impl() = default;
+ QueryConfigurationStatus_Impl(QueryConfigurationStatus_Impl&& other) = default;
+ QueryConfigurationStatus_Impl& operator=(QueryConfigurationStatus_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 SetConfigurationActive_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetConfigurationActive_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+ ~SetConfigurationActive_Impl() = default;
+ SetConfigurationActive_Impl(SetConfigurationActive_Impl&& other) = default;
+ SetConfigurationActive_Impl& operator=(SetConfigurationActive_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 SetConfigurationUnbootable_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetConfigurationUnbootable_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+ ~SetConfigurationUnbootable_Impl() = default;
+ SetConfigurationUnbootable_Impl(SetConfigurationUnbootable_Impl&& other) = default;
+ SetConfigurationUnbootable_Impl& operator=(SetConfigurationUnbootable_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 SetActiveConfigurationHealthy_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetActiveConfigurationHealthy_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~SetActiveConfigurationHealthy_Impl() = default;
+ SetActiveConfigurationHealthy_Impl(SetActiveConfigurationHealthy_Impl&& other) = default;
+ SetActiveConfigurationHealthy_Impl& operator=(SetActiveConfigurationHealthy_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 QueryActiveConfiguration = QueryActiveConfiguration_Impl<QueryActiveConfigurationResponse>;
+ using QueryConfigurationStatus = QueryConfigurationStatus_Impl<QueryConfigurationStatusResponse>;
+ using SetConfigurationActive = SetConfigurationActive_Impl<SetConfigurationActiveResponse>;
+ using SetConfigurationUnbootable = SetConfigurationUnbootable_Impl<SetConfigurationUnbootableResponse>;
+ using SetActiveConfigurationHealthy = SetActiveConfigurationHealthy_Impl<SetActiveConfigurationHealthyResponse>;
+ };
+
+ 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_; }
+
+ // Queries active configuration.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::QueryActiveConfiguration QueryActiveConfiguration();
+
+ // Queries active configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::QueryActiveConfiguration QueryActiveConfiguration(::fidl::BytePart _response_buffer);
+
+ // Queries status of |configuration|.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::QueryConfigurationStatus QueryConfigurationStatus(::llcpp::fuchsia::paver::Configuration configuration);
+
+ // Queries status of |configuration|.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::QueryConfigurationStatus QueryConfigurationStatus(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+
+ // Updates persistent metadata identifying which configuration should be selected as 'primary'
+ // for booting purposes. Should only be called after `KERNEL` as well as optional
+ // `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetConfigurationActive SetConfigurationActive(::llcpp::fuchsia::paver::Configuration configuration);
+
+ // Updates persistent metadata identifying which configuration should be selected as 'primary'
+ // for booting purposes. Should only be called after `KERNEL` as well as optional
+ // `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetConfigurationActive SetConfigurationActive(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+
+ // Updates persistent metadata identifying whether |configuration| is bootable.
+ // Should only be called in the following situations:
+ // * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified
+ // |configuration| are written.
+ // * After successfully booting from a new configuration and marking it healthy. This method
+ // would be then called on the old configuration.
+ // * After "successfully" booting from a new configuration, but encountering an unrecoverable
+ // error during health check. This method would be then called on the new configuration.
+ //
+ // If the configuration is unbootable, no action is taken.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetConfigurationUnbootable SetConfigurationUnbootable(::llcpp::fuchsia::paver::Configuration configuration);
+
+ // Updates persistent metadata identifying whether |configuration| is bootable.
+ // Should only be called in the following situations:
+ // * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified
+ // |configuration| are written.
+ // * After successfully booting from a new configuration and marking it healthy. This method
+ // would be then called on the old configuration.
+ // * After "successfully" booting from a new configuration, but encountering an unrecoverable
+ // error during health check. This method would be then called on the new configuration.
+ //
+ // If the configuration is unbootable, no action is taken.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetConfigurationUnbootable SetConfigurationUnbootable(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+
+ // Updates persistent metadata identifying that active configuration is stable. Used to signal
+ // "rollback to previous slot" logic is not needed anymore. Meant to be called in subsequent
+ // boot attempt after `SetActiveConfiguration` was called. Will return error if active
+ // configuration is currently unbootable.
+ //
+ // If the configuration is already marked healthy, no action is taken.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetActiveConfigurationHealthy SetActiveConfigurationHealthy();
+
+ // Updates persistent metadata identifying that active configuration is stable. Used to signal
+ // "rollback to previous slot" logic is not needed anymore. Meant to be called in subsequent
+ // boot attempt after `SetActiveConfiguration` was called. Will return error if active
+ // configuration is currently unbootable.
+ //
+ // If the configuration is already marked healthy, no action is taken.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetActiveConfigurationHealthy SetActiveConfigurationHealthy(::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:
+
+ // Queries active configuration.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::QueryActiveConfiguration QueryActiveConfiguration(::zx::unowned_channel _client_end);
+
+ // Queries active configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::QueryActiveConfiguration QueryActiveConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Queries status of |configuration|.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::QueryConfigurationStatus QueryConfigurationStatus(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration);
+
+ // Queries status of |configuration|.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::QueryConfigurationStatus QueryConfigurationStatus(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+
+ // Updates persistent metadata identifying which configuration should be selected as 'primary'
+ // for booting purposes. Should only be called after `KERNEL` as well as optional
+ // `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetConfigurationActive SetConfigurationActive(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration);
+
+ // Updates persistent metadata identifying which configuration should be selected as 'primary'
+ // for booting purposes. Should only be called after `KERNEL` as well as optional
+ // `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetConfigurationActive SetConfigurationActive(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+
+ // Updates persistent metadata identifying whether |configuration| is bootable.
+ // Should only be called in the following situations:
+ // * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified
+ // |configuration| are written.
+ // * After successfully booting from a new configuration and marking it healthy. This method
+ // would be then called on the old configuration.
+ // * After "successfully" booting from a new configuration, but encountering an unrecoverable
+ // error during health check. This method would be then called on the new configuration.
+ //
+ // If the configuration is unbootable, no action is taken.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetConfigurationUnbootable SetConfigurationUnbootable(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration);
+
+ // Updates persistent metadata identifying whether |configuration| is bootable.
+ // Should only be called in the following situations:
+ // * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified
+ // |configuration| are written.
+ // * After successfully booting from a new configuration and marking it healthy. This method
+ // would be then called on the old configuration.
+ // * After "successfully" booting from a new configuration, but encountering an unrecoverable
+ // error during health check. This method would be then called on the new configuration.
+ //
+ // If the configuration is unbootable, no action is taken.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetConfigurationUnbootable SetConfigurationUnbootable(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::fidl::BytePart _response_buffer);
+
+ // Updates persistent metadata identifying that active configuration is stable. Used to signal
+ // "rollback to previous slot" logic is not needed anymore. Meant to be called in subsequent
+ // boot attempt after `SetActiveConfiguration` was called. Will return error if active
+ // configuration is currently unbootable.
+ //
+ // If the configuration is already marked healthy, no action is taken.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetActiveConfigurationHealthy SetActiveConfigurationHealthy(::zx::unowned_channel _client_end);
+
+ // Updates persistent metadata identifying that active configuration is stable. Used to signal
+ // "rollback to previous slot" logic is not needed anymore. Meant to be called in subsequent
+ // boot attempt after `SetActiveConfiguration` was called. Will return error if active
+ // configuration is currently unbootable.
+ //
+ // If the configuration is already marked healthy, no action is taken.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetActiveConfigurationHealthy SetActiveConfigurationHealthy(::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:
+
+ // Queries active configuration.
+ static ::fidl::DecodeResult<QueryActiveConfigurationResponse> QueryActiveConfiguration(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Queries status of |configuration|.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ static ::fidl::DecodeResult<QueryConfigurationStatusResponse> QueryConfigurationStatus(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<QueryConfigurationStatusRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates persistent metadata identifying which configuration should be selected as 'primary'
+ // for booting purposes. Should only be called after `KERNEL` as well as optional
+ // `VERIFIED_BOOT_METADATA` assets for specified `configuration` were written successfully.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ static ::fidl::DecodeResult<SetConfigurationActiveResponse> SetConfigurationActive(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationActiveRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates persistent metadata identifying whether |configuration| is bootable.
+ // Should only be called in the following situations:
+ // * Before `KERNEL` as well as optional `VERIFIED_BOOT_METADATA` assets for specified
+ // |configuration| are written.
+ // * After successfully booting from a new configuration and marking it healthy. This method
+ // would be then called on the old configuration.
+ // * After "successfully" booting from a new configuration, but encountering an unrecoverable
+ // error during health check. This method would be then called on the new configuration.
+ //
+ // If the configuration is unbootable, no action is taken.
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `Configuration.RECOVERY` is passed in via |configuration|.
+ static ::fidl::DecodeResult<SetConfigurationUnbootableResponse> SetConfigurationUnbootable(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConfigurationUnbootableRequest> params, ::fidl::BytePart response_buffer);
+
+ // Updates persistent metadata identifying that active configuration is stable. Used to signal
+ // "rollback to previous slot" logic is not needed anymore. Meant to be called in subsequent
+ // boot attempt after `SetActiveConfiguration` was called. Will return error if active
+ // configuration is currently unbootable.
+ //
+ // If the configuration is already marked healthy, no action is taken.
+ static ::fidl::DecodeResult<SetActiveConfigurationHealthyResponse> SetActiveConfigurationHealthy(::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 = BootManager;
+ using _Base = ::fidl::CompleterBase;
+
+ class QueryActiveConfigurationCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Result result);
+ void ReplySuccess(::llcpp::fuchsia::paver::Configuration configuration);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::Configuration configuration);
+ void Reply(::fidl::DecodedMessage<QueryActiveConfigurationResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using QueryActiveConfigurationCompleter = ::fidl::Completer<QueryActiveConfigurationCompleterBase>;
+
+ virtual void QueryActiveConfiguration(QueryActiveConfigurationCompleter::Sync _completer) = 0;
+
+ class QueryConfigurationStatusCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Result result);
+ void ReplySuccess(::llcpp::fuchsia::paver::ConfigurationStatus status);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::ConfigurationStatus status);
+ void Reply(::fidl::DecodedMessage<QueryConfigurationStatusResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using QueryConfigurationStatusCompleter = ::fidl::Completer<QueryConfigurationStatusCompleterBase>;
+
+ virtual void QueryConfigurationStatus(::llcpp::fuchsia::paver::Configuration configuration, QueryConfigurationStatusCompleter::Sync _completer) = 0;
+
+ class SetConfigurationActiveCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetConfigurationActiveResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetConfigurationActiveCompleter = ::fidl::Completer<SetConfigurationActiveCompleterBase>;
+
+ virtual void SetConfigurationActive(::llcpp::fuchsia::paver::Configuration configuration, SetConfigurationActiveCompleter::Sync _completer) = 0;
+
+ class SetConfigurationUnbootableCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetConfigurationUnbootableResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetConfigurationUnbootableCompleter = ::fidl::Completer<SetConfigurationUnbootableCompleterBase>;
+
+ virtual void SetConfigurationUnbootable(::llcpp::fuchsia::paver::Configuration configuration, SetConfigurationUnbootableCompleter::Sync _completer) = 0;
+
+ class SetActiveConfigurationHealthyCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<SetActiveConfigurationHealthyResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetActiveConfigurationHealthyCompleter = ::fidl::Completer<SetActiveConfigurationHealthyCompleterBase>;
+
+ virtual void SetActiveConfigurationHealthy(SetActiveConfigurationHealthyCompleter::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 QueryActiveConfigurationRequest(const ::fidl::DecodedMessage<BootManager::QueryActiveConfigurationRequest>& _msg);
+ static void QueryActiveConfigurationResponse(const ::fidl::DecodedMessage<BootManager::QueryActiveConfigurationResponse>& _msg);
+ static void QueryConfigurationStatusRequest(const ::fidl::DecodedMessage<BootManager::QueryConfigurationStatusRequest>& _msg);
+ static void QueryConfigurationStatusResponse(const ::fidl::DecodedMessage<BootManager::QueryConfigurationStatusResponse>& _msg);
+ static void SetConfigurationActiveRequest(const ::fidl::DecodedMessage<BootManager::SetConfigurationActiveRequest>& _msg);
+ static void SetConfigurationActiveResponse(const ::fidl::DecodedMessage<BootManager::SetConfigurationActiveResponse>& _msg);
+ static void SetConfigurationUnbootableRequest(const ::fidl::DecodedMessage<BootManager::SetConfigurationUnbootableRequest>& _msg);
+ static void SetConfigurationUnbootableResponse(const ::fidl::DecodedMessage<BootManager::SetConfigurationUnbootableResponse>& _msg);
+ static void SetActiveConfigurationHealthyRequest(const ::fidl::DecodedMessage<BootManager::SetActiveConfigurationHealthyRequest>& _msg);
+ static void SetActiveConfigurationHealthyResponse(const ::fidl::DecodedMessage<BootManager::SetActiveConfigurationHealthyResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSink_ReadAsset_ResponseTable;
+
+struct DataSink_ReadAsset_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSink_ReadAsset_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::mem::Buffer asset = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkReadAssetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkReadAssetResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteAssetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteAssetResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteVolumesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteVolumesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteBootloaderRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteBootloaderResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteDataFileRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWriteDataFileResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWipeVolumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DataSinkWipeVolumeResponseTable;
+
+// Protocol for reading and writing boot partitions.
+class DataSink final {
+ DataSink() = delete;
+ public:
+
+ struct ReadAssetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkReadAssetResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ReadAssetRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::Configuration configuration;
+ ::llcpp::fuchsia::paver::Asset asset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkReadAssetRequestTable;
+ 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 = ReadAssetResponse;
+ };
+
+ struct WriteAssetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWriteAssetResponseTable;
+ 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 WriteAssetRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::Configuration configuration;
+ ::llcpp::fuchsia::paver::Asset asset;
+ ::llcpp::fuchsia::mem::Buffer payload;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWriteAssetRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = WriteAssetResponse;
+ };
+
+ struct WriteVolumesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWriteVolumesResponseTable;
+ 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 WriteVolumesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel payload;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWriteVolumesRequestTable;
+ 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 = WriteVolumesResponse;
+ };
+
+ struct WriteBootloaderResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWriteBootloaderResponseTable;
+ 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 WriteBootloaderRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::mem::Buffer payload;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWriteBootloaderRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = WriteBootloaderResponse;
+ };
+
+ struct WriteDataFileResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWriteDataFileResponseTable;
+ 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 WriteDataFileRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView filename;
+ ::llcpp::fuchsia::mem::Buffer payload;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWriteDataFileRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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 = WriteDataFileResponse;
+ };
+
+ struct WipeVolumeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DataSinkWipeVolumeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using WipeVolumeRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class ReadAsset_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadAsset_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset);
+ ~ReadAsset_Impl() = default;
+ ReadAsset_Impl(ReadAsset_Impl&& other) = default;
+ ReadAsset_Impl& operator=(ReadAsset_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 WriteAsset_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteAsset_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload);
+ ~WriteAsset_Impl() = default;
+ WriteAsset_Impl(WriteAsset_Impl&& other) = default;
+ WriteAsset_Impl& operator=(WriteAsset_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 WriteVolumes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteVolumes_Impl(::zx::unowned_channel _client_end, ::zx::channel payload);
+ ~WriteVolumes_Impl() = default;
+ WriteVolumes_Impl(WriteVolumes_Impl&& other) = default;
+ WriteVolumes_Impl& operator=(WriteVolumes_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 WriteBootloader_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteBootloader_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::mem::Buffer payload);
+ ~WriteBootloader_Impl() = default;
+ WriteBootloader_Impl(WriteBootloader_Impl&& other) = default;
+ WriteBootloader_Impl& operator=(WriteBootloader_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 WriteDataFile_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteDataFile_Impl(::zx::unowned_channel _client_end, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload);
+ ~WriteDataFile_Impl() = default;
+ WriteDataFile_Impl(WriteDataFile_Impl&& other) = default;
+ WriteDataFile_Impl& operator=(WriteDataFile_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 WipeVolume_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WipeVolume_Impl(::zx::unowned_channel _client_end);
+ ~WipeVolume_Impl() = default;
+ WipeVolume_Impl(WipeVolume_Impl&& other) = default;
+ WipeVolume_Impl& operator=(WipeVolume_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 ReadAsset = ReadAsset_Impl<ReadAssetResponse>;
+ using WriteAsset = WriteAsset_Impl<WriteAssetResponse>;
+ using WriteVolumes = WriteVolumes_Impl<WriteVolumesResponse>;
+ using WriteBootloader = WriteBootloader_Impl<WriteBootloaderResponse>;
+ using WriteDataFile = WriteDataFile_Impl<WriteDataFileResponse>;
+ using WipeVolume = WipeVolume_Impl<WipeVolumeResponse>;
+ };
+
+ // 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 ReadAsset_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadAsset_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer);
+ ~ReadAsset_Impl() = default;
+ ReadAsset_Impl(ReadAsset_Impl&& other) = default;
+ ReadAsset_Impl& operator=(ReadAsset_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 WriteAsset_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteAsset_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+ ~WriteAsset_Impl() = default;
+ WriteAsset_Impl(WriteAsset_Impl&& other) = default;
+ WriteAsset_Impl& operator=(WriteAsset_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 WriteVolumes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteVolumes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer);
+ ~WriteVolumes_Impl() = default;
+ WriteVolumes_Impl(WriteVolumes_Impl&& other) = default;
+ WriteVolumes_Impl& operator=(WriteVolumes_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 WriteBootloader_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteBootloader_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+ ~WriteBootloader_Impl() = default;
+ WriteBootloader_Impl(WriteBootloader_Impl&& other) = default;
+ WriteBootloader_Impl& operator=(WriteBootloader_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 WriteDataFile_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteDataFile_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+ ~WriteDataFile_Impl() = default;
+ WriteDataFile_Impl(WriteDataFile_Impl&& other) = default;
+ WriteDataFile_Impl& operator=(WriteDataFile_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 WipeVolume_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WipeVolume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WipeVolume_Impl() = default;
+ WipeVolume_Impl(WipeVolume_Impl&& other) = default;
+ WipeVolume_Impl& operator=(WipeVolume_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 ReadAsset = ReadAsset_Impl<ReadAssetResponse>;
+ using WriteAsset = WriteAsset_Impl<WriteAssetResponse>;
+ using WriteVolumes = WriteVolumes_Impl<WriteVolumesResponse>;
+ using WriteBootloader = WriteBootloader_Impl<WriteBootloaderResponse>;
+ using WriteDataFile = WriteDataFile_Impl<WriteDataFileResponse>;
+ using WipeVolume = WipeVolume_Impl<WipeVolumeResponse>;
+ };
+
+ 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_; }
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReadAsset ReadAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset);
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadAsset ReadAsset(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WriteAsset WriteAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteAsset WriteAsset(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WriteVolumes WriteVolumes(::zx::channel payload);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteVolumes WriteVolumes(::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WriteBootloader WriteBootloader(::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteBootloader WriteBootloader(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::WriteDataFile WriteDataFile(::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteDataFile WriteDataFile(::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WipeVolume WipeVolume();
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WipeVolume WipeVolume(::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:
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReadAsset ReadAsset(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset);
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadAsset ReadAsset(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WriteAsset WriteAsset(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteAsset WriteAsset(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WriteVolumes WriteVolumes(::zx::unowned_channel _client_end, ::zx::channel payload);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteVolumes WriteVolumes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WriteBootloader WriteBootloader(::zx::unowned_channel _client_end, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteBootloader WriteBootloader(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::WriteDataFile WriteDataFile(::zx::unowned_channel _client_end, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteDataFile WriteDataFile(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WipeVolume WipeVolume(::zx::unowned_channel _client_end);
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WipeVolume WipeVolume(::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:
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ static ::fidl::DecodeResult<ReadAssetResponse> ReadAsset(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAssetRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ static ::fidl::DecodeResult<WriteAssetResponse> WriteAsset(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAssetRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ static ::fidl::DecodeResult<WriteVolumesResponse> WriteVolumes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteVolumesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ static ::fidl::DecodeResult<WriteBootloaderResponse> WriteBootloader(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteBootloaderRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ static ::fidl::DecodeResult<WriteDataFileResponse> WriteDataFile(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteDataFileRequest> params, ::fidl::BytePart response_buffer);
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ static ::fidl::DecodeResult<WipeVolumeResponse> WipeVolume(::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 = DataSink;
+ using _Base = ::fidl::CompleterBase;
+
+ class ReadAssetCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result);
+ void ReplySuccess(::llcpp::fuchsia::mem::Buffer asset);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::mem::Buffer asset);
+ void Reply(::fidl::DecodedMessage<ReadAssetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadAssetCompleter = ::fidl::Completer<ReadAssetCompleterBase>;
+
+ virtual void ReadAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ReadAssetCompleter::Sync _completer) = 0;
+
+ class WriteAssetCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WriteAssetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteAssetCompleter = ::fidl::Completer<WriteAssetCompleterBase>;
+
+ virtual void WriteAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, WriteAssetCompleter::Sync _completer) = 0;
+
+ class WriteVolumesCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WriteVolumesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteVolumesCompleter = ::fidl::Completer<WriteVolumesCompleterBase>;
+
+ virtual void WriteVolumes(::zx::channel payload, WriteVolumesCompleter::Sync _completer) = 0;
+
+ class WriteBootloaderCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WriteBootloaderResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteBootloaderCompleter = ::fidl::Completer<WriteBootloaderCompleterBase>;
+
+ virtual void WriteBootloader(::llcpp::fuchsia::mem::Buffer payload, WriteBootloaderCompleter::Sync _completer) = 0;
+
+ class WriteDataFileCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WriteDataFileResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteDataFileCompleter = ::fidl::Completer<WriteDataFileCompleterBase>;
+
+ virtual void WriteDataFile(::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, WriteDataFileCompleter::Sync _completer) = 0;
+
+ class WipeVolumeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result);
+ void ReplySuccess(::zx::channel volume);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::channel volume);
+ void Reply(::fidl::DecodedMessage<WipeVolumeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WipeVolumeCompleter = ::fidl::Completer<WipeVolumeCompleterBase>;
+
+ virtual void WipeVolume(WipeVolumeCompleter::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 ReadAssetRequest(const ::fidl::DecodedMessage<DataSink::ReadAssetRequest>& _msg);
+ static void ReadAssetResponse(const ::fidl::DecodedMessage<DataSink::ReadAssetResponse>& _msg);
+ static void WriteAssetRequest(const ::fidl::DecodedMessage<DataSink::WriteAssetRequest>& _msg);
+ static void WriteAssetResponse(const ::fidl::DecodedMessage<DataSink::WriteAssetResponse>& _msg);
+ static void WriteVolumesRequest(const ::fidl::DecodedMessage<DataSink::WriteVolumesRequest>& _msg);
+ static void WriteVolumesResponse(const ::fidl::DecodedMessage<DataSink::WriteVolumesResponse>& _msg);
+ static void WriteBootloaderRequest(const ::fidl::DecodedMessage<DataSink::WriteBootloaderRequest>& _msg);
+ static void WriteBootloaderResponse(const ::fidl::DecodedMessage<DataSink::WriteBootloaderResponse>& _msg);
+ static void WriteDataFileRequest(const ::fidl::DecodedMessage<DataSink::WriteDataFileRequest>& _msg);
+ static void WriteDataFileResponse(const ::fidl::DecodedMessage<DataSink::WriteDataFileResponse>& _msg);
+ static void WipeVolumeRequest(const ::fidl::DecodedMessage<DataSink::WipeVolumeRequest>& _msg);
+ static void WipeVolumeResponse(const ::fidl::DecodedMessage<DataSink::WipeVolumeResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkReadAssetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkReadAssetResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteAssetRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteAssetResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteVolumesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteVolumesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteBootloaderRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteBootloaderResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteDataFileRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWriteDataFileResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWipeVolumeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWipeVolumeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkInitializePartitionTablesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkInitializePartitionTablesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWipePartitionTablesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_paver_DynamicDataSinkWipePartitionTablesResponseTable;
+
+// Specialized DataSink with dynamic partition tables.
+class DynamicDataSink final {
+ DynamicDataSink() = delete;
+ public:
+
+ struct ReadAssetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkReadAssetResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ReadAssetRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::Configuration configuration;
+ ::llcpp::fuchsia::paver::Asset asset;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkReadAssetRequestTable;
+ 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 = ReadAssetResponse;
+ };
+
+ struct WriteAssetResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWriteAssetResponseTable;
+ 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 WriteAssetRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::Configuration configuration;
+ ::llcpp::fuchsia::paver::Asset asset;
+ ::llcpp::fuchsia::mem::Buffer payload;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWriteAssetRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 40;
+ 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 = WriteAssetResponse;
+ };
+
+ struct WriteVolumesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWriteVolumesResponseTable;
+ 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 WriteVolumesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel payload;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWriteVolumesRequestTable;
+ 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 = WriteVolumesResponse;
+ };
+
+ struct WriteBootloaderResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWriteBootloaderResponseTable;
+ 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 WriteBootloaderRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::mem::Buffer payload;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWriteBootloaderRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ 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 = WriteBootloaderResponse;
+ };
+
+ struct WriteDataFileResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWriteDataFileResponseTable;
+ 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 WriteDataFileRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView filename;
+ ::llcpp::fuchsia::mem::Buffer payload;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWriteDataFileRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 4096;
+ 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 = WriteDataFileResponse;
+ };
+
+ struct WipeVolumeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWipeVolumeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using WipeVolumeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct InitializePartitionTablesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkInitializePartitionTablesResponseTable;
+ 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 InitializePartitionTablesRequest = ::fidl::AnyZeroArgMessage;
+
+ struct WipePartitionTablesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_paver_DynamicDataSinkWipePartitionTablesResponseTable;
+ 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 WipePartitionTablesRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class ReadAsset_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadAsset_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset);
+ ~ReadAsset_Impl() = default;
+ ReadAsset_Impl(ReadAsset_Impl&& other) = default;
+ ReadAsset_Impl& operator=(ReadAsset_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 WriteAsset_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteAsset_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload);
+ ~WriteAsset_Impl() = default;
+ WriteAsset_Impl(WriteAsset_Impl&& other) = default;
+ WriteAsset_Impl& operator=(WriteAsset_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 WriteVolumes_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteVolumes_Impl(::zx::unowned_channel _client_end, ::zx::channel payload);
+ ~WriteVolumes_Impl() = default;
+ WriteVolumes_Impl(WriteVolumes_Impl&& other) = default;
+ WriteVolumes_Impl& operator=(WriteVolumes_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 WriteBootloader_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteBootloader_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::mem::Buffer payload);
+ ~WriteBootloader_Impl() = default;
+ WriteBootloader_Impl(WriteBootloader_Impl&& other) = default;
+ WriteBootloader_Impl& operator=(WriteBootloader_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 WriteDataFile_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WriteDataFile_Impl(::zx::unowned_channel _client_end, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload);
+ ~WriteDataFile_Impl() = default;
+ WriteDataFile_Impl(WriteDataFile_Impl&& other) = default;
+ WriteDataFile_Impl& operator=(WriteDataFile_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 WipeVolume_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WipeVolume_Impl(::zx::unowned_channel _client_end);
+ ~WipeVolume_Impl() = default;
+ WipeVolume_Impl(WipeVolume_Impl&& other) = default;
+ WipeVolume_Impl& operator=(WipeVolume_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 InitializePartitionTables_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ InitializePartitionTables_Impl(::zx::unowned_channel _client_end);
+ ~InitializePartitionTables_Impl() = default;
+ InitializePartitionTables_Impl(InitializePartitionTables_Impl&& other) = default;
+ InitializePartitionTables_Impl& operator=(InitializePartitionTables_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 WipePartitionTables_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WipePartitionTables_Impl(::zx::unowned_channel _client_end);
+ ~WipePartitionTables_Impl() = default;
+ WipePartitionTables_Impl(WipePartitionTables_Impl&& other) = default;
+ WipePartitionTables_Impl& operator=(WipePartitionTables_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 ReadAsset = ReadAsset_Impl<ReadAssetResponse>;
+ using WriteAsset = WriteAsset_Impl<WriteAssetResponse>;
+ using WriteVolumes = WriteVolumes_Impl<WriteVolumesResponse>;
+ using WriteBootloader = WriteBootloader_Impl<WriteBootloaderResponse>;
+ using WriteDataFile = WriteDataFile_Impl<WriteDataFileResponse>;
+ using WipeVolume = WipeVolume_Impl<WipeVolumeResponse>;
+ using InitializePartitionTables = InitializePartitionTables_Impl<InitializePartitionTablesResponse>;
+ using WipePartitionTables = WipePartitionTables_Impl<WipePartitionTablesResponse>;
+ };
+
+ // 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 ReadAsset_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadAsset_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer);
+ ~ReadAsset_Impl() = default;
+ ReadAsset_Impl(ReadAsset_Impl&& other) = default;
+ ReadAsset_Impl& operator=(ReadAsset_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 WriteAsset_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteAsset_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+ ~WriteAsset_Impl() = default;
+ WriteAsset_Impl(WriteAsset_Impl&& other) = default;
+ WriteAsset_Impl& operator=(WriteAsset_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 WriteVolumes_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteVolumes_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer);
+ ~WriteVolumes_Impl() = default;
+ WriteVolumes_Impl(WriteVolumes_Impl&& other) = default;
+ WriteVolumes_Impl& operator=(WriteVolumes_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 WriteBootloader_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteBootloader_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+ ~WriteBootloader_Impl() = default;
+ WriteBootloader_Impl(WriteBootloader_Impl&& other) = default;
+ WriteBootloader_Impl& operator=(WriteBootloader_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 WriteDataFile_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WriteDataFile_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+ ~WriteDataFile_Impl() = default;
+ WriteDataFile_Impl(WriteDataFile_Impl&& other) = default;
+ WriteDataFile_Impl& operator=(WriteDataFile_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 WipeVolume_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WipeVolume_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WipeVolume_Impl() = default;
+ WipeVolume_Impl(WipeVolume_Impl&& other) = default;
+ WipeVolume_Impl& operator=(WipeVolume_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 InitializePartitionTables_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ InitializePartitionTables_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~InitializePartitionTables_Impl() = default;
+ InitializePartitionTables_Impl(InitializePartitionTables_Impl&& other) = default;
+ InitializePartitionTables_Impl& operator=(InitializePartitionTables_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 WipePartitionTables_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WipePartitionTables_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WipePartitionTables_Impl() = default;
+ WipePartitionTables_Impl(WipePartitionTables_Impl&& other) = default;
+ WipePartitionTables_Impl& operator=(WipePartitionTables_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 ReadAsset = ReadAsset_Impl<ReadAssetResponse>;
+ using WriteAsset = WriteAsset_Impl<WriteAssetResponse>;
+ using WriteVolumes = WriteVolumes_Impl<WriteVolumesResponse>;
+ using WriteBootloader = WriteBootloader_Impl<WriteBootloaderResponse>;
+ using WriteDataFile = WriteDataFile_Impl<WriteDataFileResponse>;
+ using WipeVolume = WipeVolume_Impl<WipeVolumeResponse>;
+ using InitializePartitionTables = InitializePartitionTables_Impl<InitializePartitionTablesResponse>;
+ using WipePartitionTables = WipePartitionTables_Impl<WipePartitionTablesResponse>;
+ };
+
+ 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_; }
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReadAsset ReadAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset);
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadAsset ReadAsset(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WriteAsset WriteAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteAsset WriteAsset(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WriteVolumes WriteVolumes(::zx::channel payload);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteVolumes WriteVolumes(::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WriteBootloader WriteBootloader(::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteBootloader WriteBootloader(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::WriteDataFile WriteDataFile(::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WriteDataFile WriteDataFile(::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WipeVolume WipeVolume();
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WipeVolume WipeVolume(::fidl::BytePart _response_buffer);
+
+ // Initializes partitions on given block device.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::InitializePartitionTables InitializePartitionTables();
+
+ // Initializes partitions on given block device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::InitializePartitionTables InitializePartitionTables(::fidl::BytePart _response_buffer);
+
+ // Wipes all entries from the partition table of the specified block device.
+ // Currently only supported on devices with a GPT.
+ //
+ // *WARNING*: This API may destructively remove non-fuchsia maintained partitions from
+ // the block device.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WipePartitionTables WipePartitionTables();
+
+ // Wipes all entries from the partition table of the specified block device.
+ // Currently only supported on devices with a GPT.
+ //
+ // *WARNING*: This API may destructively remove non-fuchsia maintained partitions from
+ // the block device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WipePartitionTables WipePartitionTables(::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:
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReadAsset ReadAsset(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset);
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadAsset ReadAsset(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::fidl::BytePart _response_buffer);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WriteAsset WriteAsset(::zx::unowned_channel _client_end, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteAsset WriteAsset(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WriteVolumes WriteVolumes(::zx::unowned_channel _client_end, ::zx::channel payload);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteVolumes WriteVolumes(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel payload, ::fidl::BytePart _response_buffer);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WriteBootloader WriteBootloader(::zx::unowned_channel _client_end, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteBootloader WriteBootloader(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::WriteDataFile WriteDataFile(::zx::unowned_channel _client_end, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WriteDataFile WriteDataFile(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, ::fidl::BytePart _response_buffer);
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WipeVolume WipeVolume(::zx::unowned_channel _client_end);
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WipeVolume WipeVolume(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Initializes partitions on given block device.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::InitializePartitionTables InitializePartitionTables(::zx::unowned_channel _client_end);
+
+ // Initializes partitions on given block device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::InitializePartitionTables InitializePartitionTables(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Wipes all entries from the partition table of the specified block device.
+ // Currently only supported on devices with a GPT.
+ //
+ // *WARNING*: This API may destructively remove non-fuchsia maintained partitions from
+ // the block device.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WipePartitionTables WipePartitionTables(::zx::unowned_channel _client_end);
+
+ // Wipes all entries from the partition table of the specified block device.
+ // Currently only supported on devices with a GPT.
+ //
+ // *WARNING*: This API may destructively remove non-fuchsia maintained partitions from
+ // the block device.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WipePartitionTables WipePartitionTables(::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:
+
+ // Reads partition corresponding to |configuration| and |asset| into a
+ // vmo and returns it.
+ static ::fidl::DecodeResult<ReadAssetResponse> ReadAsset(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ReadAssetRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes partition corresponding to `configuration` and `asset` with data from `payload`.
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`. Will zero out rest of the partition if `payload` is smaller
+ // than the size of the partition being written.
+ //
+ //
+ // Returns `ZX_ERR_INVALID_ARGS` if `configuration` specifies active configuration.
+ static ::fidl::DecodeResult<WriteAssetResponse> WriteAsset(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteAssetRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes FVM with data from streamed via `payload`. This potentially affects all
+ // configurations.
+ static ::fidl::DecodeResult<WriteVolumesResponse> WriteVolumes(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteVolumesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes bootloader partition with data from `payload`.
+ //
+ // `payload` may need to be resized to the partition size, so the provided vmo must have
+ // been created with `ZX_VMO_RESIZABLE` or must be a child VMO that was created with
+ // `ZX_VMO_CHILD_RESIZABLE`.
+ static ::fidl::DecodeResult<WriteBootloaderResponse> WriteBootloader(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteBootloaderRequest> params, ::fidl::BytePart response_buffer);
+
+ // Writes /data/`filename` with data from `payload`. Overwrites file if it already exists.
+ static ::fidl::DecodeResult<WriteDataFileResponse> WriteDataFile(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WriteDataFileRequest> params, ::fidl::BytePart response_buffer);
+
+ // Wipes the FVM partition from the device. Should not be confused with factory reset, which
+ // is less intrusive. The result is that the default FVM volumes are re-created, but empty.
+ //
+ // Notable use cases include recovering from corrupted FVM as well as setting device to a
+ // "clean" state for automation.
+ //
+ // If |block_device| is not provided, the paver will perform a search for the the FVM.
+ // If multiple block devices have valid GPT, |block_device| can be provided to specify
+ // which one to target. It assumed that channel backing |block_device| also implements
+ // `fuchsia.io.Node` for now.
+ //
+ // On success, returns a channel to the initialized FVM volume.
+ static ::fidl::DecodeResult<WipeVolumeResponse> WipeVolume(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Initializes partitions on given block device.
+ static ::fidl::DecodeResult<InitializePartitionTablesResponse> InitializePartitionTables(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Wipes all entries from the partition table of the specified block device.
+ // Currently only supported on devices with a GPT.
+ //
+ // *WARNING*: This API may destructively remove non-fuchsia maintained partitions from
+ // the block device.
+ static ::fidl::DecodeResult<WipePartitionTablesResponse> WipePartitionTables(::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 = DynamicDataSink;
+ using _Base = ::fidl::CompleterBase;
+
+ class ReadAssetCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result);
+ void ReplySuccess(::llcpp::fuchsia::mem::Buffer asset);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::DataSink_ReadAsset_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::mem::Buffer asset);
+ void Reply(::fidl::DecodedMessage<ReadAssetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadAssetCompleter = ::fidl::Completer<ReadAssetCompleterBase>;
+
+ virtual void ReadAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ReadAssetCompleter::Sync _completer) = 0;
+
+ class WriteAssetCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WriteAssetResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteAssetCompleter = ::fidl::Completer<WriteAssetCompleterBase>;
+
+ virtual void WriteAsset(::llcpp::fuchsia::paver::Configuration configuration, ::llcpp::fuchsia::paver::Asset asset, ::llcpp::fuchsia::mem::Buffer payload, WriteAssetCompleter::Sync _completer) = 0;
+
+ class WriteVolumesCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WriteVolumesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteVolumesCompleter = ::fidl::Completer<WriteVolumesCompleterBase>;
+
+ virtual void WriteVolumes(::zx::channel payload, WriteVolumesCompleter::Sync _completer) = 0;
+
+ class WriteBootloaderCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WriteBootloaderResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteBootloaderCompleter = ::fidl::Completer<WriteBootloaderCompleterBase>;
+
+ virtual void WriteBootloader(::llcpp::fuchsia::mem::Buffer payload, WriteBootloaderCompleter::Sync _completer) = 0;
+
+ class WriteDataFileCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WriteDataFileResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WriteDataFileCompleter = ::fidl::Completer<WriteDataFileCompleterBase>;
+
+ virtual void WriteDataFile(::fidl::StringView filename, ::llcpp::fuchsia::mem::Buffer payload, WriteDataFileCompleter::Sync _completer) = 0;
+
+ class WipeVolumeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result);
+ void ReplySuccess(::zx::channel volume);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::paver::DataSink_WipeVolume_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::channel volume);
+ void Reply(::fidl::DecodedMessage<WipeVolumeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WipeVolumeCompleter = ::fidl::Completer<WipeVolumeCompleterBase>;
+
+ virtual void WipeVolume(WipeVolumeCompleter::Sync _completer) = 0;
+
+ class InitializePartitionTablesCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<InitializePartitionTablesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using InitializePartitionTablesCompleter = ::fidl::Completer<InitializePartitionTablesCompleterBase>;
+
+ virtual void InitializePartitionTables(InitializePartitionTablesCompleter::Sync _completer) = 0;
+
+ class WipePartitionTablesCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<WipePartitionTablesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WipePartitionTablesCompleter = ::fidl::Completer<WipePartitionTablesCompleterBase>;
+
+ virtual void WipePartitionTables(WipePartitionTablesCompleter::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 ReadAssetRequest(const ::fidl::DecodedMessage<DynamicDataSink::ReadAssetRequest>& _msg);
+ static void ReadAssetResponse(const ::fidl::DecodedMessage<DynamicDataSink::ReadAssetResponse>& _msg);
+ static void WriteAssetRequest(const ::fidl::DecodedMessage<DynamicDataSink::WriteAssetRequest>& _msg);
+ static void WriteAssetResponse(const ::fidl::DecodedMessage<DynamicDataSink::WriteAssetResponse>& _msg);
+ static void WriteVolumesRequest(const ::fidl::DecodedMessage<DynamicDataSink::WriteVolumesRequest>& _msg);
+ static void WriteVolumesResponse(const ::fidl::DecodedMessage<DynamicDataSink::WriteVolumesResponse>& _msg);
+ static void WriteBootloaderRequest(const ::fidl::DecodedMessage<DynamicDataSink::WriteBootloaderRequest>& _msg);
+ static void WriteBootloaderResponse(const ::fidl::DecodedMessage<DynamicDataSink::WriteBootloaderResponse>& _msg);
+ static void WriteDataFileRequest(const ::fidl::DecodedMessage<DynamicDataSink::WriteDataFileRequest>& _msg);
+ static void WriteDataFileResponse(const ::fidl::DecodedMessage<DynamicDataSink::WriteDataFileResponse>& _msg);
+ static void WipeVolumeRequest(const ::fidl::DecodedMessage<DynamicDataSink::WipeVolumeRequest>& _msg);
+ static void WipeVolumeResponse(const ::fidl::DecodedMessage<DynamicDataSink::WipeVolumeResponse>& _msg);
+ static void InitializePartitionTablesRequest(const ::fidl::DecodedMessage<DynamicDataSink::InitializePartitionTablesRequest>& _msg);
+ static void InitializePartitionTablesResponse(const ::fidl::DecodedMessage<DynamicDataSink::InitializePartitionTablesResponse>& _msg);
+ static void WipePartitionTablesRequest(const ::fidl::DecodedMessage<DynamicDataSink::WipePartitionTablesRequest>& _msg);
+ static void WipePartitionTablesResponse(const ::fidl::DecodedMessage<DynamicDataSink::WipePartitionTablesResponse>& _msg);
+ };
+};
+
+} // namespace paver
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::ReadInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::ReadInfo>);
+static_assert(offsetof(::llcpp::fuchsia::paver::ReadInfo, offset) == 0);
+static_assert(offsetof(::llcpp::fuchsia::paver::ReadInfo, size) == 8);
+static_assert(sizeof(::llcpp::fuchsia::paver::ReadInfo) == ::llcpp::fuchsia::paver::ReadInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::ReadResult> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::ReadResult>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::Paver::FindDataSinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::Paver::FindDataSinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::Paver::FindDataSinkRequest)
+ == ::llcpp::fuchsia::paver::Paver::FindDataSinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::Paver::FindDataSinkRequest, data_sink) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::Paver::UseBlockDeviceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::Paver::UseBlockDeviceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::Paver::UseBlockDeviceRequest)
+ == ::llcpp::fuchsia::paver::Paver::UseBlockDeviceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::Paver::UseBlockDeviceRequest, block_device) == 16);
+static_assert(offsetof(::llcpp::fuchsia::paver::Paver::UseBlockDeviceRequest, data_sink) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::Paver::FindBootManagerRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::Paver::FindBootManagerRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::Paver::FindBootManagerRequest)
+ == ::llcpp::fuchsia::paver::Paver::FindBootManagerRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::Paver::FindBootManagerRequest, boot_manager) == 16);
+static_assert(offsetof(::llcpp::fuchsia::paver::Paver::FindBootManagerRequest, initialize) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::PayloadStream::RegisterVmoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::PayloadStream::RegisterVmoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::PayloadStream::RegisterVmoRequest)
+ == ::llcpp::fuchsia::paver::PayloadStream::RegisterVmoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::PayloadStream::RegisterVmoRequest, vmo) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::PayloadStream::RegisterVmoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::PayloadStream::RegisterVmoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::PayloadStream::RegisterVmoResponse)
+ == ::llcpp::fuchsia::paver::PayloadStream::RegisterVmoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::PayloadStream::RegisterVmoResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::PayloadStream::ReadDataResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::PayloadStream::ReadDataResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::PayloadStream::ReadDataResponse)
+ == ::llcpp::fuchsia::paver::PayloadStream::ReadDataResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::PayloadStream::ReadDataResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink_WipeVolume_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::DataSink_WipeVolume_Response>);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink_WipeVolume_Response, volume) == 0);
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink_WipeVolume_Response) == ::llcpp::fuchsia::paver::DataSink_WipeVolume_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink_WipeVolume_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::DataSink_WipeVolume_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response>);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response, status) == 0);
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response) == ::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::BootManager_QueryConfigurationStatus_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response>);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response, configuration) == 0);
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response) == ::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::BootManager_QueryActiveConfiguration_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager::QueryActiveConfigurationResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::BootManager::QueryActiveConfigurationResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager::QueryActiveConfigurationResponse)
+ == ::llcpp::fuchsia::paver::BootManager::QueryActiveConfigurationResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager::QueryActiveConfigurationResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusRequest)
+ == ::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusRequest, configuration) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusResponse)
+ == ::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager::QueryConfigurationStatusResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveRequest)
+ == ::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveRequest, configuration) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveResponse)
+ == ::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager::SetConfigurationActiveResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableRequest)
+ == ::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableRequest, configuration) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableResponse)
+ == ::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager::SetConfigurationUnbootableResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::BootManager::SetActiveConfigurationHealthyResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::BootManager::SetActiveConfigurationHealthyResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::BootManager::SetActiveConfigurationHealthyResponse)
+ == ::llcpp::fuchsia::paver::BootManager::SetActiveConfigurationHealthyResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::BootManager::SetActiveConfigurationHealthyResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink_ReadAsset_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::DataSink_ReadAsset_Response>);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink_ReadAsset_Response, asset) == 0);
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink_ReadAsset_Response) == ::llcpp::fuchsia::paver::DataSink_ReadAsset_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink_ReadAsset_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::paver::DataSink_ReadAsset_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::ReadAssetRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::ReadAssetRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::ReadAssetRequest)
+ == ::llcpp::fuchsia::paver::DataSink::ReadAssetRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::ReadAssetRequest, configuration) == 16);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::ReadAssetRequest, asset) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::ReadAssetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::ReadAssetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::ReadAssetResponse)
+ == ::llcpp::fuchsia::paver::DataSink::ReadAssetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::ReadAssetResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WriteAssetRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WriteAssetRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WriteAssetRequest)
+ == ::llcpp::fuchsia::paver::DataSink::WriteAssetRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteAssetRequest, configuration) == 16);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteAssetRequest, asset) == 20);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteAssetRequest, payload) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WriteAssetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WriteAssetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WriteAssetResponse)
+ == ::llcpp::fuchsia::paver::DataSink::WriteAssetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteAssetResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WriteVolumesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WriteVolumesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WriteVolumesRequest)
+ == ::llcpp::fuchsia::paver::DataSink::WriteVolumesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteVolumesRequest, payload) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WriteVolumesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WriteVolumesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WriteVolumesResponse)
+ == ::llcpp::fuchsia::paver::DataSink::WriteVolumesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteVolumesResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WriteBootloaderRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WriteBootloaderRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WriteBootloaderRequest)
+ == ::llcpp::fuchsia::paver::DataSink::WriteBootloaderRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteBootloaderRequest, payload) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WriteBootloaderResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WriteBootloaderResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WriteBootloaderResponse)
+ == ::llcpp::fuchsia::paver::DataSink::WriteBootloaderResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteBootloaderResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WriteDataFileRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WriteDataFileRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WriteDataFileRequest)
+ == ::llcpp::fuchsia::paver::DataSink::WriteDataFileRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteDataFileRequest, filename) == 16);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteDataFileRequest, payload) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WriteDataFileResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WriteDataFileResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WriteDataFileResponse)
+ == ::llcpp::fuchsia::paver::DataSink::WriteDataFileResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WriteDataFileResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DataSink::WipeVolumeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DataSink::WipeVolumeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DataSink::WipeVolumeResponse)
+ == ::llcpp::fuchsia::paver::DataSink::WipeVolumeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DataSink::WipeVolumeResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetRequest)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetRequest, configuration) == 16);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetRequest, asset) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetResponse)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::ReadAssetResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetRequest)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetRequest, configuration) == 16);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetRequest, asset) == 20);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetRequest, payload) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetResponse)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteAssetResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesRequest)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesRequest, payload) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesResponse)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteVolumesResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderRequest)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderRequest, payload) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderResponse)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteBootloaderResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileRequest)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileRequest, filename) == 16);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileRequest, payload) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileResponse)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WriteDataFileResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WipeVolumeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WipeVolumeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WipeVolumeResponse)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WipeVolumeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WipeVolumeResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::InitializePartitionTablesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::InitializePartitionTablesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::InitializePartitionTablesResponse)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::InitializePartitionTablesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::InitializePartitionTablesResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::paver::DynamicDataSink::WipePartitionTablesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::paver::DynamicDataSink::WipePartitionTablesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::paver::DynamicDataSink::WipePartitionTablesResponse)
+ == ::llcpp::fuchsia::paver::DynamicDataSink::WipePartitionTablesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::paver::DynamicDataSink::WipePartitionTablesResponse, status) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-perfmon-cpu/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-perfmon-cpu/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..6f6fc71
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-perfmon-cpu/gen/llcpp/fidl.cc
@@ -0,0 +1,1192 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/perfmon/cpu/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace perfmon {
+namespace cpu {
+
+void ::llcpp::fuchsia::perfmon::cpu::Controller_Start_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_Start_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_Start_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_Start_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_StageConfig_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_StageConfig_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_StageConfig_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Controller_Initialize_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Controller_Initialize_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Controller_Initialize_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kController_GetProperties_Ordinal = 0x4a9f6d2100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetProperties_GenOrdinal = 0x81aa89f0ac87173lu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetPropertiesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetPropertiesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Initialize_Ordinal = 0x6fe7b83800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Initialize_GenOrdinal = 0x4a03bc2d8348c317lu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerInitializeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerInitializeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Terminate_Ordinal = 0x57b56a800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Terminate_GenOrdinal = 0xa591f0cfbb1a6f9lu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerTerminateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerTerminateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetAllocation_Ordinal = 0x6c4a81f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetAllocation_GenOrdinal = 0x3b4bffd18849f074lu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetAllocationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetAllocationResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_StageConfig_Ordinal = 0x5889caf900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_StageConfig_GenOrdinal = 0x340032f97698973alu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStageConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStageConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetConfig_Ordinal = 0x1ec2af4000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetConfig_GenOrdinal = 0x5da0a02d12fbfdd3lu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetConfigResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_GetBufferHandle_Ordinal = 0x7fb9183100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_GetBufferHandle_GenOrdinal = 0x1a49fd7f34915efflu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetBufferHandleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetBufferHandleResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Start_Ordinal = 0x4efe358200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Start_GenOrdinal = 0x3c166469384c06f8lu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStartResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kController_Stop_Ordinal = 0x21f2d4200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kController_Stop_GenOrdinal = 0x36a98bbc8ee7e3d2lu;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStopResponseTable;
+
+} // namespace
+template <>
+Controller::ResultOf::GetProperties_Impl<Controller::GetPropertiesResponse>::GetProperties_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPropertiesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPropertiesRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPropertiesRequest));
+ ::fidl::DecodedMessage<GetPropertiesRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetProperties(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetProperties Controller::SyncClient::GetProperties() {
+ return ResultOf::GetProperties(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetProperties Controller::Call::GetProperties(::zx::unowned_channel _client_end) {
+ return ResultOf::GetProperties(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetProperties_Impl<Controller::GetPropertiesResponse>::GetProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPropertiesRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPropertiesRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPropertiesRequest));
+ ::fidl::DecodedMessage<GetPropertiesRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetProperties(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetProperties Controller::SyncClient::GetProperties(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetProperties(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetProperties Controller::Call::GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetProperties(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetPropertiesResponse> Controller::InPlace::GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPropertiesRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPropertiesRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetPropertiesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetPropertiesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPropertiesRequest, GetPropertiesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetPropertiesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Initialize_Impl<Controller::InitializeResponse>::Initialize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InitializeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, InitializeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<InitializeRequest*>(_write_bytes);
+ _request.allocation = std::move(allocation);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(InitializeRequest));
+ ::fidl::DecodedMessage<InitializeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Initialize(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::Initialize Controller::SyncClient::Initialize(::llcpp::fuchsia::perfmon::cpu::Allocation allocation) {
+ return ResultOf::Initialize(::zx::unowned_channel(this->channel_), std::move(allocation));
+}
+
+Controller::ResultOf::Initialize Controller::Call::Initialize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation) {
+ return ResultOf::Initialize(std::move(_client_end), std::move(allocation));
+}
+
+template <>
+Controller::UnownedResultOf::Initialize_Impl<Controller::InitializeResponse>::Initialize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < InitializeRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<InitializeResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, InitializeRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<InitializeRequest*>(_request_buffer.data());
+ _request.allocation = std::move(allocation);
+ _request_buffer.set_actual(sizeof(InitializeRequest));
+ ::fidl::DecodedMessage<InitializeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::Initialize(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::Initialize Controller::SyncClient::Initialize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Initialize(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(allocation), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::Initialize Controller::Call::Initialize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Initialize(std::move(_client_end), std::move(_request_buffer), std::move(allocation), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::InitializeResponse> Controller::InPlace::Initialize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<InitializeRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::InitializeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::InitializeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<InitializeRequest, InitializeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::InitializeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Terminate_Impl<Controller::TerminateResponse>::Terminate_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TerminateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, TerminateRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(TerminateRequest));
+ ::fidl::DecodedMessage<TerminateRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Terminate(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::Terminate Controller::SyncClient::Terminate() {
+ return ResultOf::Terminate(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::Terminate Controller::Call::Terminate(::zx::unowned_channel _client_end) {
+ return ResultOf::Terminate(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Controller::TerminateResponse> Controller::InPlace::Terminate(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(TerminateRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<TerminateRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::TerminateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::TerminateResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<TerminateRequest, TerminateResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::TerminateResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetAllocation_Impl<Controller::GetAllocationResponse>::GetAllocation_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAllocationRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAllocationRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAllocationRequest));
+ ::fidl::DecodedMessage<GetAllocationRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetAllocation(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetAllocation Controller::SyncClient::GetAllocation() {
+ return ResultOf::GetAllocation(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetAllocation Controller::Call::GetAllocation(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAllocation(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetAllocation_Impl<Controller::GetAllocationResponse>::GetAllocation_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAllocationRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAllocationRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAllocationRequest));
+ ::fidl::DecodedMessage<GetAllocationRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetAllocation(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetAllocation Controller::SyncClient::GetAllocation(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAllocation(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetAllocation Controller::Call::GetAllocation(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAllocation(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetAllocationResponse> Controller::InPlace::GetAllocation(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAllocationRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAllocationRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetAllocationRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetAllocationResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAllocationRequest, GetAllocationResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetAllocationResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::StageConfig_Impl<Controller::StageConfigResponse>::StageConfig_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::perfmon::cpu::Config config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StageConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StageConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<StageConfigRequest*>(_write_bytes);
+ _request.config = std::move(config);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StageConfigRequest));
+ ::fidl::DecodedMessage<StageConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::StageConfig(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::StageConfig Controller::SyncClient::StageConfig(::llcpp::fuchsia::perfmon::cpu::Config config) {
+ return ResultOf::StageConfig(::zx::unowned_channel(this->channel_), std::move(config));
+}
+
+Controller::ResultOf::StageConfig Controller::Call::StageConfig(::zx::unowned_channel _client_end, ::llcpp::fuchsia::perfmon::cpu::Config config) {
+ return ResultOf::StageConfig(std::move(_client_end), std::move(config));
+}
+
+template <>
+Controller::UnownedResultOf::StageConfig_Impl<Controller::StageConfigResponse>::StageConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Config config, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < StageConfigRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<StageConfigResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, StageConfigRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<StageConfigRequest*>(_request_buffer.data());
+ _request.config = std::move(config);
+ _request_buffer.set_actual(sizeof(StageConfigRequest));
+ ::fidl::DecodedMessage<StageConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::StageConfig(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::StageConfig Controller::SyncClient::StageConfig(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Config config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StageConfig(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::StageConfig Controller::Call::StageConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Config config, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::StageConfig(std::move(_client_end), std::move(_request_buffer), std::move(config), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::StageConfigResponse> Controller::InPlace::StageConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StageConfigRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::StageConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StageConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StageConfigRequest, StageConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StageConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetConfig_Impl<Controller::GetConfigResponse>::GetConfig_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetConfigRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetConfigRequest));
+ ::fidl::DecodedMessage<GetConfigRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetConfig(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetConfig Controller::SyncClient::GetConfig() {
+ return ResultOf::GetConfig(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::GetConfig Controller::Call::GetConfig(::zx::unowned_channel _client_end) {
+ return ResultOf::GetConfig(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::GetConfig_Impl<Controller::GetConfigResponse>::GetConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetConfigRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetConfigRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetConfigRequest));
+ ::fidl::DecodedMessage<GetConfigRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetConfig(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetConfig Controller::SyncClient::GetConfig(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetConfig(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetConfig Controller::Call::GetConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetConfig(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetConfigResponse> Controller::InPlace::GetConfig(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetConfigRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetConfigRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::GetConfigRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetConfigResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetConfigRequest, GetConfigResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetConfigResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::GetBufferHandle_Impl<Controller::GetBufferHandleResponse>::GetBufferHandle_Impl(::zx::unowned_channel _client_end, uint32_t descriptor) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferHandleRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetBufferHandleRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferHandleRequest*>(_write_bytes);
+ _request.descriptor = std::move(descriptor);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBufferHandleRequest));
+ ::fidl::DecodedMessage<GetBufferHandleRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::GetBufferHandle(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Controller::ResultOf::GetBufferHandle Controller::SyncClient::GetBufferHandle(uint32_t descriptor) {
+ return ResultOf::GetBufferHandle(::zx::unowned_channel(this->channel_), std::move(descriptor));
+}
+
+Controller::ResultOf::GetBufferHandle Controller::Call::GetBufferHandle(::zx::unowned_channel _client_end, uint32_t descriptor) {
+ return ResultOf::GetBufferHandle(std::move(_client_end), std::move(descriptor));
+}
+
+template <>
+Controller::UnownedResultOf::GetBufferHandle_Impl<Controller::GetBufferHandleResponse>::GetBufferHandle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetBufferHandleRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetBufferHandleResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetBufferHandleRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetBufferHandleRequest*>(_request_buffer.data());
+ _request.descriptor = std::move(descriptor);
+ _request_buffer.set_actual(sizeof(GetBufferHandleRequest));
+ ::fidl::DecodedMessage<GetBufferHandleRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::GetBufferHandle(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::GetBufferHandle Controller::SyncClient::GetBufferHandle(::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBufferHandle(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(descriptor), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::GetBufferHandle Controller::Call::GetBufferHandle(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBufferHandle(std::move(_client_end), std::move(_request_buffer), std::move(descriptor), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::GetBufferHandleResponse> Controller::InPlace::GetBufferHandle(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferHandleRequest> params, ::fidl::BytePart response_buffer) {
+ Controller::SetTransactionHeaderFor::GetBufferHandleRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetBufferHandleResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetBufferHandleRequest, GetBufferHandleResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::GetBufferHandleResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Start_Impl<Controller::StartResponse>::Start_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StartRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StartRequest));
+ ::fidl::DecodedMessage<StartRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Start(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::Start Controller::SyncClient::Start() {
+ return ResultOf::Start(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::Start Controller::Call::Start(::zx::unowned_channel _client_end) {
+ return ResultOf::Start(std::move(_client_end));
+}
+
+template <>
+Controller::UnownedResultOf::Start_Impl<Controller::StartResponse>::Start_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(StartRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, StartRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(StartRequest));
+ ::fidl::DecodedMessage<StartRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Controller::InPlace::Start(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Controller::UnownedResultOf::Start Controller::SyncClient::Start(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Start(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Controller::UnownedResultOf::Start Controller::Call::Start(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Start(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Controller::StartResponse> Controller::InPlace::Start(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(StartRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<StartRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::StartRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StartResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StartRequest, StartResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StartResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Controller::ResultOf::Stop_Impl<Controller::StopResponse>::Stop_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StopRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, StopRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(StopRequest));
+ ::fidl::DecodedMessage<StopRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Controller::InPlace::Stop(std::move(_client_end), Super::response_buffer()));
+}
+
+Controller::ResultOf::Stop Controller::SyncClient::Stop() {
+ return ResultOf::Stop(::zx::unowned_channel(this->channel_));
+}
+
+Controller::ResultOf::Stop Controller::Call::Stop(::zx::unowned_channel _client_end) {
+ return ResultOf::Stop(std::move(_client_end));
+}
+
+::fidl::DecodeResult<Controller::StopResponse> Controller::InPlace::Stop(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(StopRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<StopRequest> params(std::move(_request_buffer));
+ Controller::SetTransactionHeaderFor::StopRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StopResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<StopRequest, StopResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Controller::StopResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Controller::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kController_GetProperties_Ordinal:
+ case kController_GetProperties_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPropertiesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetProperties(
+ Interface::GetPropertiesCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Initialize_Ordinal:
+ case kController_Initialize_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<InitializeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Initialize(std::move(message->allocation),
+ Interface::InitializeCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Terminate_Ordinal:
+ case kController_Terminate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<TerminateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Terminate(
+ Interface::TerminateCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetAllocation_Ordinal:
+ case kController_GetAllocation_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAllocationRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAllocation(
+ Interface::GetAllocationCompleter::Sync(txn));
+ return true;
+ }
+ case kController_StageConfig_Ordinal:
+ case kController_StageConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StageConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->StageConfig(std::move(message->config),
+ Interface::StageConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetConfig_Ordinal:
+ case kController_GetConfig_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetConfigRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetConfig(
+ Interface::GetConfigCompleter::Sync(txn));
+ return true;
+ }
+ case kController_GetBufferHandle_Ordinal:
+ case kController_GetBufferHandle_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetBufferHandleRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetBufferHandle(std::move(message->descriptor),
+ Interface::GetBufferHandleCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Start_Ordinal:
+ case kController_Start_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StartRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Start(
+ Interface::StartCompleter::Sync(txn));
+ return true;
+ }
+ case kController_Stop_Ordinal:
+ case kController_Stop_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<StopRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Stop(
+ Interface::StopCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Controller::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Controller::Interface::GetPropertiesCompleterBase::Reply(::llcpp::fuchsia::perfmon::cpu::Properties properties) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPropertiesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetPropertiesResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetPropertiesResponse(
+ ::fidl::DecodedMessage<GetPropertiesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPropertiesResponse::PrimarySize,
+ GetPropertiesResponse::PrimarySize)));
+ _response.properties = std::move(properties);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPropertiesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetPropertiesResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetPropertiesCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Properties properties) {
+ if (_buffer.capacity() < GetPropertiesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetPropertiesResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetPropertiesResponse(
+ ::fidl::DecodedMessage<GetPropertiesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPropertiesResponse::PrimarySize,
+ GetPropertiesResponse::PrimarySize)));
+ _response.properties = std::move(properties);
+ _buffer.set_actual(sizeof(GetPropertiesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetPropertiesResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetPropertiesCompleterBase::Reply(::fidl::DecodedMessage<GetPropertiesResponse> params) {
+ Controller::SetTransactionHeaderFor::GetPropertiesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::InitializeCompleterBase::Reply(::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InitializeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ InitializeResponse _response = {};
+ Controller::SetTransactionHeaderFor::InitializeResponse(
+ ::fidl::DecodedMessage<InitializeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InitializeResponse::PrimarySize,
+ InitializeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::InitializeCompleterBase::ReplySuccess() {
+ Controller_Initialize_Response response;
+
+ Reply(Controller_Initialize_Result::WithResponse(&response));
+}
+void Controller::Interface::InitializeCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_Initialize_Result::WithErr(&error));
+}
+
+void Controller::Interface::InitializeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Result result) {
+ if (_buffer.capacity() < InitializeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ InitializeResponse _response = {};
+ Controller::SetTransactionHeaderFor::InitializeResponse(
+ ::fidl::DecodedMessage<InitializeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InitializeResponse::PrimarySize,
+ InitializeResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::InitializeCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_Initialize_Response response;
+
+ Reply(std::move(_buffer), Controller_Initialize_Result::WithResponse(&response));
+}
+
+void Controller::Interface::InitializeCompleterBase::Reply(::fidl::DecodedMessage<InitializeResponse> params) {
+ Controller::SetTransactionHeaderFor::InitializeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::TerminateCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<TerminateResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<TerminateResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::TerminateResponse(
+ ::fidl::DecodedMessage<TerminateResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ TerminateResponse::PrimarySize,
+ TerminateResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(TerminateResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<TerminateResponse>(std::move(_response_bytes)));
+}
+
+
+void Controller::Interface::GetAllocationCompleterBase::Reply(::llcpp::fuchsia::perfmon::cpu::Allocation* allocation) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAllocationResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetAllocationResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetAllocationResponse(
+ ::fidl::DecodedMessage<GetAllocationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAllocationResponse::PrimarySize,
+ GetAllocationResponse::PrimarySize)));
+ _response.allocation = std::move(allocation);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetAllocationCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Allocation* allocation) {
+ if (_buffer.capacity() < GetAllocationResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetAllocationResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetAllocationResponse(
+ ::fidl::DecodedMessage<GetAllocationResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAllocationResponse::PrimarySize,
+ GetAllocationResponse::PrimarySize)));
+ _response.allocation = std::move(allocation);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetAllocationCompleterBase::Reply(::fidl::DecodedMessage<GetAllocationResponse> params) {
+ Controller::SetTransactionHeaderFor::GetAllocationResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::StageConfigCompleterBase::Reply(::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StageConfigResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ StageConfigResponse _response = {};
+ Controller::SetTransactionHeaderFor::StageConfigResponse(
+ ::fidl::DecodedMessage<StageConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StageConfigResponse::PrimarySize,
+ StageConfigResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::StageConfigCompleterBase::ReplySuccess() {
+ Controller_StageConfig_Response response;
+
+ Reply(Controller_StageConfig_Result::WithResponse(&response));
+}
+void Controller::Interface::StageConfigCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_StageConfig_Result::WithErr(&error));
+}
+
+void Controller::Interface::StageConfigCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Result result) {
+ if (_buffer.capacity() < StageConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ StageConfigResponse _response = {};
+ Controller::SetTransactionHeaderFor::StageConfigResponse(
+ ::fidl::DecodedMessage<StageConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StageConfigResponse::PrimarySize,
+ StageConfigResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::StageConfigCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_StageConfig_Response response;
+
+ Reply(std::move(_buffer), Controller_StageConfig_Result::WithResponse(&response));
+}
+
+void Controller::Interface::StageConfigCompleterBase::Reply(::fidl::DecodedMessage<StageConfigResponse> params) {
+ Controller::SetTransactionHeaderFor::StageConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetConfigCompleterBase::Reply(::llcpp::fuchsia::perfmon::cpu::Config* config) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetConfigResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetConfigResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetConfigResponse(
+ ::fidl::DecodedMessage<GetConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetConfigResponse::PrimarySize,
+ GetConfigResponse::PrimarySize)));
+ _response.config = std::move(config);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetConfigCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Config* config) {
+ if (_buffer.capacity() < GetConfigResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetConfigResponse _response = {};
+ Controller::SetTransactionHeaderFor::GetConfigResponse(
+ ::fidl::DecodedMessage<GetConfigResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetConfigResponse::PrimarySize,
+ GetConfigResponse::PrimarySize)));
+ _response.config = std::move(config);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Controller::Interface::GetConfigCompleterBase::Reply(::fidl::DecodedMessage<GetConfigResponse> params) {
+ Controller::SetTransactionHeaderFor::GetConfigResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::GetBufferHandleCompleterBase::Reply(::zx::vmo vmo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBufferHandleResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetBufferHandleResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::GetBufferHandleResponse(
+ ::fidl::DecodedMessage<GetBufferHandleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferHandleResponse::PrimarySize,
+ GetBufferHandleResponse::PrimarySize)));
+ _response.vmo = std::move(vmo);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBufferHandleResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetBufferHandleResponse>(std::move(_response_bytes)));
+}
+
+void Controller::Interface::GetBufferHandleCompleterBase::Reply(::fidl::BytePart _buffer, ::zx::vmo vmo) {
+ if (_buffer.capacity() < GetBufferHandleResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetBufferHandleResponse*>(_buffer.data());
+ Controller::SetTransactionHeaderFor::GetBufferHandleResponse(
+ ::fidl::DecodedMessage<GetBufferHandleResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBufferHandleResponse::PrimarySize,
+ GetBufferHandleResponse::PrimarySize)));
+ _response.vmo = std::move(vmo);
+ _buffer.set_actual(sizeof(GetBufferHandleResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetBufferHandleResponse>(std::move(_buffer)));
+}
+
+void Controller::Interface::GetBufferHandleCompleterBase::Reply(::fidl::DecodedMessage<GetBufferHandleResponse> params) {
+ Controller::SetTransactionHeaderFor::GetBufferHandleResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::StartCompleterBase::Reply(::llcpp::fuchsia::perfmon::cpu::Controller_Start_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StartResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ StartResponse _response = {};
+ Controller::SetTransactionHeaderFor::StartResponse(
+ ::fidl::DecodedMessage<StartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartResponse::PrimarySize,
+ StartResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::StartCompleterBase::ReplySuccess() {
+ Controller_Start_Response response;
+
+ Reply(Controller_Start_Result::WithResponse(&response));
+}
+void Controller::Interface::StartCompleterBase::ReplyError(int32_t error) {
+ Reply(Controller_Start_Result::WithErr(&error));
+}
+
+void Controller::Interface::StartCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Controller_Start_Result result) {
+ if (_buffer.capacity() < StartResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ StartResponse _response = {};
+ Controller::SetTransactionHeaderFor::StartResponse(
+ ::fidl::DecodedMessage<StartResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StartResponse::PrimarySize,
+ StartResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Controller::Interface::StartCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ Controller_Start_Response response;
+
+ Reply(std::move(_buffer), Controller_Start_Result::WithResponse(&response));
+}
+
+void Controller::Interface::StartCompleterBase::Reply(::fidl::DecodedMessage<StartResponse> params) {
+ Controller::SetTransactionHeaderFor::StartResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Controller::Interface::StopCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<StopResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<StopResponse*>(_write_bytes);
+ Controller::SetTransactionHeaderFor::StopResponse(
+ ::fidl::DecodedMessage<StopResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ StopResponse::PrimarySize,
+ StopResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(StopResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<StopResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Controller::SetTransactionHeaderFor::GetPropertiesRequest(const ::fidl::DecodedMessage<Controller::GetPropertiesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetProperties_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetPropertiesResponse(const ::fidl::DecodedMessage<Controller::GetPropertiesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetProperties_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::InitializeRequest(const ::fidl::DecodedMessage<Controller::InitializeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Initialize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::InitializeResponse(const ::fidl::DecodedMessage<Controller::InitializeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Initialize_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::TerminateRequest(const ::fidl::DecodedMessage<Controller::TerminateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Terminate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::TerminateResponse(const ::fidl::DecodedMessage<Controller::TerminateResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Terminate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetAllocationRequest(const ::fidl::DecodedMessage<Controller::GetAllocationRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetAllocation_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetAllocationResponse(const ::fidl::DecodedMessage<Controller::GetAllocationResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetAllocation_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::StageConfigRequest(const ::fidl::DecodedMessage<Controller::StageConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_StageConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::StageConfigResponse(const ::fidl::DecodedMessage<Controller::StageConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_StageConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetConfigRequest(const ::fidl::DecodedMessage<Controller::GetConfigRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetConfigResponse(const ::fidl::DecodedMessage<Controller::GetConfigResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetConfig_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::GetBufferHandleRequest(const ::fidl::DecodedMessage<Controller::GetBufferHandleRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetBufferHandle_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::GetBufferHandleResponse(const ::fidl::DecodedMessage<Controller::GetBufferHandleResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_GetBufferHandle_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::StartRequest(const ::fidl::DecodedMessage<Controller::StartRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Start_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::StartResponse(const ::fidl::DecodedMessage<Controller::StartResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Start_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Controller::SetTransactionHeaderFor::StopRequest(const ::fidl::DecodedMessage<Controller::StopRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Stop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Controller::SetTransactionHeaderFor::StopResponse(const ::fidl::DecodedMessage<Controller::StopResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kController_Stop_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace cpu
+} // namespace perfmon
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-perfmon-cpu/gen/llcpp/include/fuchsia/perfmon/cpu/llcpp/fidl.h b/zircon/system/fidl/fuchsia-perfmon-cpu/gen/llcpp/include/fuchsia/perfmon/cpu/llcpp/fidl.h
new file mode 100644
index 0000000..ded2bfb
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-perfmon-cpu/gen/llcpp/include/fuchsia/perfmon/cpu/llcpp/fidl.h
@@ -0,0 +1,1709 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace perfmon {
+namespace cpu {
+
+class PropertyFlags final {
+public:
+ constexpr PropertyFlags() : value_(0u) {}
+ explicit constexpr PropertyFlags(uint64_t value) : value_(value) {}
+ const static PropertyFlags HAS_LAST_BRANCH;
+ const static PropertyFlags mask;
+
+ explicit constexpr inline operator uint64_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const PropertyFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const PropertyFlags& other) const { return value_ != other.value_; }
+ constexpr inline PropertyFlags operator~() const;
+ constexpr inline PropertyFlags operator|(const PropertyFlags& other) const;
+ constexpr inline PropertyFlags operator&(const PropertyFlags& other) const;
+ constexpr inline PropertyFlags operator^(const PropertyFlags& other) const;
+ constexpr inline void operator|=(const PropertyFlags& other);
+ constexpr inline void operator&=(const PropertyFlags& other);
+ constexpr inline void operator^=(const PropertyFlags& other);
+
+private:
+ uint64_t value_;
+};
+constexpr const ::llcpp::fuchsia::perfmon::cpu::PropertyFlags PropertyFlags::HAS_LAST_BRANCH = ::llcpp::fuchsia::perfmon::cpu::PropertyFlags(1u);
+constexpr const ::llcpp::fuchsia::perfmon::cpu::PropertyFlags PropertyFlags::mask = ::llcpp::fuchsia::perfmon::cpu::PropertyFlags(1u);
+
+constexpr inline ::llcpp::fuchsia::perfmon::cpu::PropertyFlags PropertyFlags::operator~() const {
+ return ::llcpp::fuchsia::perfmon::cpu::PropertyFlags(static_cast<uint64_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::perfmon::cpu::PropertyFlags PropertyFlags::operator|(
+ const ::llcpp::fuchsia::perfmon::cpu::PropertyFlags& other) const {
+ return ::llcpp::fuchsia::perfmon::cpu::PropertyFlags(static_cast<uint64_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::perfmon::cpu::PropertyFlags PropertyFlags::operator&(
+ const ::llcpp::fuchsia::perfmon::cpu::PropertyFlags& other) const {
+ return ::llcpp::fuchsia::perfmon::cpu::PropertyFlags(static_cast<uint64_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::perfmon::cpu::PropertyFlags PropertyFlags::operator^(
+ const ::llcpp::fuchsia::perfmon::cpu::PropertyFlags& other) const {
+ return ::llcpp::fuchsia::perfmon::cpu::PropertyFlags(static_cast<uint64_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void PropertyFlags::operator|=(
+ const ::llcpp::fuchsia::perfmon::cpu::PropertyFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void PropertyFlags::operator&=(
+ const ::llcpp::fuchsia::perfmon::cpu::PropertyFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void PropertyFlags::operator^=(
+ const ::llcpp::fuchsia::perfmon::cpu::PropertyFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+struct Properties;
+class EventConfigFlags final {
+public:
+ constexpr EventConfigFlags() : value_(0u) {}
+ explicit constexpr EventConfigFlags(uint32_t value) : value_(value) {}
+ const static EventConfigFlags COLLECT_OS;
+ const static EventConfigFlags COLLECT_USER;
+ const static EventConfigFlags COLLECT_PC;
+ const static EventConfigFlags IS_TIMEBASE;
+ const static EventConfigFlags COLLECT_LAST_BRANCH;
+ const static EventConfigFlags mask;
+
+ explicit constexpr inline operator uint32_t() const { return value_; }
+ explicit constexpr inline operator bool() const { return static_cast<bool>(value_); }
+ constexpr inline bool operator==(const EventConfigFlags& other) const { return value_ == other.value_; }
+ constexpr inline bool operator!=(const EventConfigFlags& other) const { return value_ != other.value_; }
+ constexpr inline EventConfigFlags operator~() const;
+ constexpr inline EventConfigFlags operator|(const EventConfigFlags& other) const;
+ constexpr inline EventConfigFlags operator&(const EventConfigFlags& other) const;
+ constexpr inline EventConfigFlags operator^(const EventConfigFlags& other) const;
+ constexpr inline void operator|=(const EventConfigFlags& other);
+ constexpr inline void operator&=(const EventConfigFlags& other);
+ constexpr inline void operator^=(const EventConfigFlags& other);
+
+private:
+ uint32_t value_;
+};
+constexpr const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::COLLECT_OS = ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(1u);
+constexpr const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::COLLECT_USER = ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(2u);
+constexpr const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::COLLECT_PC = ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(4u);
+constexpr const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::IS_TIMEBASE = ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(8u);
+constexpr const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::COLLECT_LAST_BRANCH = ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(16u);
+constexpr const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::mask = ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(31u);
+
+constexpr inline ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::operator~() const {
+ return ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(static_cast<uint32_t>(~this->value_ & mask.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::operator|(
+ const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags& other) const {
+ return ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(static_cast<uint32_t>(this->value_ | other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::operator&(
+ const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags& other) const {
+ return ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(static_cast<uint32_t>(this->value_ & other.value_));
+}
+
+constexpr inline ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags EventConfigFlags::operator^(
+ const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags& other) const {
+ return ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags(static_cast<uint32_t>(this->value_ ^ other.value_));
+}
+
+constexpr inline void EventConfigFlags::operator|=(
+ const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags& other) {
+ this->value_ |= other.value_;
+}
+
+constexpr inline void EventConfigFlags::operator&=(
+ const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags& other) {
+ this->value_ &= other.value_;
+}
+
+constexpr inline void EventConfigFlags::operator^=(
+ const ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags& other) {
+ this->value_ ^= other.value_;
+}
+
+struct EventConfig;
+struct Config;
+struct Controller_Start_Response;
+struct Controller_Start_Result;
+struct Controller_StageConfig_Response;
+struct Controller_StageConfig_Result;
+struct Controller_Initialize_Response;
+struct Controller_Initialize_Result;
+struct Allocation;
+class Controller;
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_Controller_Start_ResultTable;
+
+struct Controller_Start_Result {
+ Controller_Start_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_Start_Result WithResponse(::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response* val) {
+ Controller_Start_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_Start_Result WithErr(int32_t* val) {
+ Controller_Start_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_Controller_Start_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_Controller_StageConfig_ResultTable;
+
+struct Controller_StageConfig_Result {
+ Controller_StageConfig_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_StageConfig_Result WithResponse(::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response* val) {
+ Controller_StageConfig_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_StageConfig_Result WithErr(int32_t* val) {
+ Controller_StageConfig_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_Controller_StageConfig_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_Controller_Initialize_ResultTable;
+
+struct Controller_Initialize_Result {
+ Controller_Initialize_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Controller_Initialize_Result WithResponse(::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response* val) {
+ Controller_Initialize_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Controller_Initialize_Result WithErr(int32_t* val) {
+ Controller_Initialize_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_Controller_Initialize_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_PropertiesTable;
+
+// The properties of this system.
+struct Properties {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_PropertiesTable;
+ 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;
+
+ // S/W API version = `API_VERSION`.
+ uint16_t api_version = {};
+
+ // The H/W Performance Monitor version.
+ // This is the version defined by the architecture.
+ uint16_t pm_version = {};
+
+ // The maximum number of events that can be simultaneously supported.
+ // The combination of events that can be simultaneously supported is
+ // architecture/model specific.
+ uint16_t max_num_events = {};
+
+ // The maximum number of fixed events that can be simultaneously
+ // supported, and their maximum width.
+ // These values are for informational/display purposes.
+ uint16_t max_num_fixed_events = {};
+
+ uint16_t max_fixed_counter_width = {};
+
+ // The maximum number of programmable events that can be simultaneously
+ // supported, and their maximum width.
+ // These values are for informational/display purposes.
+ uint16_t max_num_programmable_events = {};
+
+ uint16_t max_programmable_counter_width = {};
+
+ // The maximum number of misc events that can be simultaneously
+ // supported, and their maximum width.
+ // These values are for informational/display purposes.
+ uint16_t max_num_misc_events = {};
+
+ uint16_t max_misc_counter_width = {};
+
+ // Various flags.
+ ::llcpp::fuchsia::perfmon::cpu::PropertyFlags flags = {};
+};
+
+// The maximum number of events we support simultaneously.
+// Typically the h/w supports less than this, e.g., 7 or so.
+constexpr uint16_t MAX_NUM_EVENTS = 32u;
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_EventConfigTable;
+
+struct EventConfig {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_EventConfigTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 12;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Event to collect data for.
+ // The values are architecture specific ids.
+ // Each event may appear at most once.
+ uint16_t event = {};
+
+ // Sampling rate.
+ // - If rate is non-zero then when the event gets this many hits data is
+ // collected (e.g., pc, time).
+ // The rate can be non-zero for counting based events only.
+ // - If rate is zero then:
+ // If there is a timebase event then data for this event is collected
+ // when data for the timebase event is collected.
+ // Otherwise data for the event is collected once, when tracing stops.
+ uint32_t rate = {};
+
+ // Flags for the event.
+ ::llcpp::fuchsia::perfmon::cpu::EventConfigFlags flags = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ConfigTable;
+
+// Passed to `StageConfig()` to select the data to be collected.
+struct Config {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ConfigTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 384;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Events to collect data for.
+ ::fidl::Array<::llcpp::fuchsia::perfmon::cpu::EventConfig, 32> events = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_Controller_Start_ResponseTable;
+
+struct Controller_Start_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_Controller_Start_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_Controller_StageConfig_ResponseTable;
+
+struct Controller_StageConfig_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_Controller_StageConfig_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_Controller_Initialize_ResponseTable;
+
+struct Controller_Initialize_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_Controller_Initialize_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_AllocationTable;
+
+// The allocation configuration for a data collection run.
+// This is generally the first call to allocate resources for a trace,
+// "trace" is used generically here: == "data collection run".
+struct Allocation {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_AllocationTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The number of buffers to allocate for trace data.
+ // This must be #cpus for now.
+ uint32_t num_buffers = {};
+
+ // The size of each buffer in 4K pages.
+ // Each cpu gets same buffer size.
+ uint32_t buffer_size_in_pages = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetPropertiesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetPropertiesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerInitializeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerInitializeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerTerminateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerTerminateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetAllocationRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetAllocationResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStageConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStageConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetConfigRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetConfigResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetBufferHandleRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerGetBufferHandleResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStartRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStartResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStopRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_perfmon_cpu_ControllerStopResponseTable;
+
+class Controller final {
+ Controller() = delete;
+ public:
+
+ struct GetPropertiesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::perfmon::cpu::Properties properties;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerGetPropertiesResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 48;
+ 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 GetPropertiesRequest = ::fidl::AnyZeroArgMessage;
+
+ struct InitializeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerInitializeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct InitializeRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::perfmon::cpu::Allocation allocation;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerInitializeRequestTable;
+ 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 = InitializeResponse;
+ };
+
+ using TerminateResponse = ::fidl::AnyZeroArgMessage;
+ using TerminateRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAllocationResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::perfmon::cpu::Allocation* allocation;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerGetAllocationResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ 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;
+ };
+ using GetAllocationRequest = ::fidl::AnyZeroArgMessage;
+
+ struct StageConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerStageConfigResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct StageConfigRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::perfmon::cpu::Config config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerStageConfigRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 400;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 400;
+ 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 = StageConfigResponse;
+ };
+
+ struct GetConfigResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::perfmon::cpu::Config* config;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerGetConfigResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ static constexpr uint32_t MaxOutOfLine = 384;
+ 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 GetConfigRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetBufferHandleResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo vmo;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerGetBufferHandleResponseTable;
+ 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;
+ };
+ struct GetBufferHandleRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t descriptor;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerGetBufferHandleRequestTable;
+ 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 = GetBufferHandleResponse;
+ };
+
+ struct StartResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::perfmon::cpu::Controller_Start_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_perfmon_cpu_ControllerStartResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using StartRequest = ::fidl::AnyZeroArgMessage;
+
+ using StopResponse = ::fidl::AnyZeroArgMessage;
+ using StopRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetProperties_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetProperties_Impl(::zx::unowned_channel _client_end);
+ ~GetProperties_Impl() = default;
+ GetProperties_Impl(GetProperties_Impl&& other) = default;
+ GetProperties_Impl& operator=(GetProperties_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 Initialize_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Initialize_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation);
+ ~Initialize_Impl() = default;
+ Initialize_Impl(Initialize_Impl&& other) = default;
+ Initialize_Impl& operator=(Initialize_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 Terminate_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Terminate_Impl(::zx::unowned_channel _client_end);
+ ~Terminate_Impl() = default;
+ Terminate_Impl(Terminate_Impl&& other) = default;
+ Terminate_Impl& operator=(Terminate_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 GetAllocation_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAllocation_Impl(::zx::unowned_channel _client_end);
+ ~GetAllocation_Impl() = default;
+ GetAllocation_Impl(GetAllocation_Impl&& other) = default;
+ GetAllocation_Impl& operator=(GetAllocation_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 StageConfig_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ StageConfig_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::perfmon::cpu::Config config);
+ ~StageConfig_Impl() = default;
+ StageConfig_Impl(StageConfig_Impl&& other) = default;
+ StageConfig_Impl& operator=(StageConfig_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 GetConfig_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetConfig_Impl(::zx::unowned_channel _client_end);
+ ~GetConfig_Impl() = default;
+ GetConfig_Impl(GetConfig_Impl&& other) = default;
+ GetConfig_Impl& operator=(GetConfig_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 GetBufferHandle_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetBufferHandle_Impl(::zx::unowned_channel _client_end, uint32_t descriptor);
+ ~GetBufferHandle_Impl() = default;
+ GetBufferHandle_Impl(GetBufferHandle_Impl&& other) = default;
+ GetBufferHandle_Impl& operator=(GetBufferHandle_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 Start_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Start_Impl(::zx::unowned_channel _client_end);
+ ~Start_Impl() = default;
+ Start_Impl(Start_Impl&& other) = default;
+ Start_Impl& operator=(Start_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 Stop_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Stop_Impl(::zx::unowned_channel _client_end);
+ ~Stop_Impl() = default;
+ Stop_Impl(Stop_Impl&& other) = default;
+ Stop_Impl& operator=(Stop_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 GetProperties = GetProperties_Impl<GetPropertiesResponse>;
+ using Initialize = Initialize_Impl<InitializeResponse>;
+ using Terminate = Terminate_Impl<TerminateResponse>;
+ using GetAllocation = GetAllocation_Impl<GetAllocationResponse>;
+ using StageConfig = StageConfig_Impl<StageConfigResponse>;
+ using GetConfig = GetConfig_Impl<GetConfigResponse>;
+ using GetBufferHandle = GetBufferHandle_Impl<GetBufferHandleResponse>;
+ using Start = Start_Impl<StartResponse>;
+ using Stop = Stop_Impl<StopResponse>;
+ };
+
+ // 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 GetProperties_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetProperties_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetProperties_Impl() = default;
+ GetProperties_Impl(GetProperties_Impl&& other) = default;
+ GetProperties_Impl& operator=(GetProperties_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 Initialize_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Initialize_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation, ::fidl::BytePart _response_buffer);
+ ~Initialize_Impl() = default;
+ Initialize_Impl(Initialize_Impl&& other) = default;
+ Initialize_Impl& operator=(Initialize_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 Terminate_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Terminate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Terminate_Impl() = default;
+ Terminate_Impl(Terminate_Impl&& other) = default;
+ Terminate_Impl& operator=(Terminate_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 GetAllocation_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAllocation_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAllocation_Impl() = default;
+ GetAllocation_Impl(GetAllocation_Impl&& other) = default;
+ GetAllocation_Impl& operator=(GetAllocation_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 StageConfig_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ StageConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Config config, ::fidl::BytePart _response_buffer);
+ ~StageConfig_Impl() = default;
+ StageConfig_Impl(StageConfig_Impl&& other) = default;
+ StageConfig_Impl& operator=(StageConfig_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 GetConfig_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetConfig_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetConfig_Impl() = default;
+ GetConfig_Impl(GetConfig_Impl&& other) = default;
+ GetConfig_Impl& operator=(GetConfig_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 GetBufferHandle_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetBufferHandle_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+ ~GetBufferHandle_Impl() = default;
+ GetBufferHandle_Impl(GetBufferHandle_Impl&& other) = default;
+ GetBufferHandle_Impl& operator=(GetBufferHandle_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 Start_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Start_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Start_Impl() = default;
+ Start_Impl(Start_Impl&& other) = default;
+ Start_Impl& operator=(Start_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 Stop_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Stop_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Stop_Impl() = default;
+ Stop_Impl(Stop_Impl&& other) = default;
+ Stop_Impl& operator=(Stop_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 GetProperties = GetProperties_Impl<GetPropertiesResponse>;
+ using Initialize = Initialize_Impl<InitializeResponse>;
+ using Terminate = Terminate_Impl<TerminateResponse>;
+ using GetAllocation = GetAllocation_Impl<GetAllocationResponse>;
+ using StageConfig = StageConfig_Impl<StageConfigResponse>;
+ using GetConfig = GetConfig_Impl<GetConfigResponse>;
+ using GetBufferHandle = GetBufferHandle_Impl<GetBufferHandleResponse>;
+ using Start = Start_Impl<StartResponse>;
+ using Stop = Stop_Impl<StopResponse>;
+ };
+
+ 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_; }
+
+ // Fetch the performance monitor properties of the system.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetProperties GetProperties();
+
+ // Fetch the performance monitor properties of the system.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetProperties GetProperties(::fidl::BytePart _response_buffer);
+
+ // Create a trace, allocating the needed trace buffers and other resources.
+ // "other resources" is basically a catch-all for other things that will
+ // be needed. This does not include reserving the events, that is done
+ // later by `StageConfig()`.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Initialize Initialize(::llcpp::fuchsia::perfmon::cpu::Allocation allocation);
+
+ // Create a trace, allocating the needed trace buffers and other resources.
+ // "other resources" is basically a catch-all for other things that will
+ // be needed. This does not include reserving the events, that is done
+ // later by `StageConfig()`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Initialize Initialize(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation, ::fidl::BytePart _response_buffer);
+
+ // Free all trace buffers and any other resources allocated for the trace.
+ // This is also done when the connection is closed.
+ // Tracing is first stopped if not already stopped.
+ // May be called multiple times.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Terminate Terminate();
+
+
+ // Return the trace allocation configuration, if there is one.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAllocation GetAllocation();
+
+ // Return the trace allocation configuration, if there is one.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAllocation GetAllocation(::fidl::BytePart _response_buffer);
+
+ // Stage performance monitor specification for a cpu.
+ // Must be called with data collection off and after `Initialize()`.
+ // Note: This doesn't actually configure the h/w, this just stages
+ // the values for subsequent use by `Start()`.
+ // Allocates 448 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::StageConfig StageConfig(::llcpp::fuchsia::perfmon::cpu::Config config);
+
+ // Stage performance monitor specification for a cpu.
+ // Must be called with data collection off and after `Initialize()`.
+ // Note: This doesn't actually configure the h/w, this just stages
+ // the values for subsequent use by `Start()`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::StageConfig StageConfig(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Config config, ::fidl::BytePart _response_buffer);
+
+ // Fetch performance monitor specification for a cpu, if it exists.
+ // Must be called with data collection off and after `StageConfig()`.
+ // Allocates 424 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetConfig GetConfig();
+
+ // Fetch performance monitor specification for a cpu, if it exists.
+ // Must be called with data collection off and after `StageConfig()`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetConfig GetConfig(::fidl::BytePart _response_buffer);
+
+ // Return a handle of a trace buffer, if it exists, and if `descriptor`
+ // is valid.
+ // `descriptor` is (0, 1, 2, ..., `num_buffers`-1)
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetBufferHandle GetBufferHandle(uint32_t descriptor);
+
+ // Return a handle of a trace buffer, if it exists, and if `descriptor`
+ // is valid.
+ // `descriptor` is (0, 1, 2, ..., `num_buffers`-1)
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetBufferHandle GetBufferHandle(::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+
+ // Turn on data collection.
+ // Must be called after `Initialize()` + `StageConfig()` and with data
+ // collection off.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Start Start();
+
+ // Turn on data collection.
+ // Must be called after `Initialize()` + `StageConfig()` and with data
+ // collection off.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Start Start(::fidl::BytePart _response_buffer);
+
+ // Turn off data collection.
+ // May be called any time after `Initialize()` has been called and before
+ // `Terminate()`. If called at other times the call is ignored.
+ // May be called multiple times.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Stop Stop();
+
+
+ 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:
+
+ // Fetch the performance monitor properties of the system.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetProperties GetProperties(::zx::unowned_channel _client_end);
+
+ // Fetch the performance monitor properties of the system.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetProperties GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Create a trace, allocating the needed trace buffers and other resources.
+ // "other resources" is basically a catch-all for other things that will
+ // be needed. This does not include reserving the events, that is done
+ // later by `StageConfig()`.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Initialize Initialize(::zx::unowned_channel _client_end, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation);
+
+ // Create a trace, allocating the needed trace buffers and other resources.
+ // "other resources" is basically a catch-all for other things that will
+ // be needed. This does not include reserving the events, that is done
+ // later by `StageConfig()`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Initialize Initialize(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Allocation allocation, ::fidl::BytePart _response_buffer);
+
+ // Free all trace buffers and any other resources allocated for the trace.
+ // This is also done when the connection is closed.
+ // Tracing is first stopped if not already stopped.
+ // May be called multiple times.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Terminate Terminate(::zx::unowned_channel _client_end);
+
+
+ // Return the trace allocation configuration, if there is one.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAllocation GetAllocation(::zx::unowned_channel _client_end);
+
+ // Return the trace allocation configuration, if there is one.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAllocation GetAllocation(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Stage performance monitor specification for a cpu.
+ // Must be called with data collection off and after `Initialize()`.
+ // Note: This doesn't actually configure the h/w, this just stages
+ // the values for subsequent use by `Start()`.
+ // Allocates 448 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::StageConfig StageConfig(::zx::unowned_channel _client_end, ::llcpp::fuchsia::perfmon::cpu::Config config);
+
+ // Stage performance monitor specification for a cpu.
+ // Must be called with data collection off and after `Initialize()`.
+ // Note: This doesn't actually configure the h/w, this just stages
+ // the values for subsequent use by `Start()`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::StageConfig StageConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::perfmon::cpu::Config config, ::fidl::BytePart _response_buffer);
+
+ // Fetch performance monitor specification for a cpu, if it exists.
+ // Must be called with data collection off and after `StageConfig()`.
+ // Allocates 424 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetConfig GetConfig(::zx::unowned_channel _client_end);
+
+ // Fetch performance monitor specification for a cpu, if it exists.
+ // Must be called with data collection off and after `StageConfig()`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetConfig GetConfig(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Return a handle of a trace buffer, if it exists, and if `descriptor`
+ // is valid.
+ // `descriptor` is (0, 1, 2, ..., `num_buffers`-1)
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetBufferHandle GetBufferHandle(::zx::unowned_channel _client_end, uint32_t descriptor);
+
+ // Return a handle of a trace buffer, if it exists, and if `descriptor`
+ // is valid.
+ // `descriptor` is (0, 1, 2, ..., `num_buffers`-1)
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetBufferHandle GetBufferHandle(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t descriptor, ::fidl::BytePart _response_buffer);
+
+ // Turn on data collection.
+ // Must be called after `Initialize()` + `StageConfig()` and with data
+ // collection off.
+ // Allocates 64 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Start Start(::zx::unowned_channel _client_end);
+
+ // Turn on data collection.
+ // Must be called after `Initialize()` + `StageConfig()` and with data
+ // collection off.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Start Start(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Turn off data collection.
+ // May be called any time after `Initialize()` has been called and before
+ // `Terminate()`. If called at other times the call is ignored.
+ // May be called multiple times.
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Stop Stop(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // Fetch the performance monitor properties of the system.
+ static ::fidl::DecodeResult<GetPropertiesResponse> GetProperties(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Create a trace, allocating the needed trace buffers and other resources.
+ // "other resources" is basically a catch-all for other things that will
+ // be needed. This does not include reserving the events, that is done
+ // later by `StageConfig()`.
+ static ::fidl::DecodeResult<InitializeResponse> Initialize(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<InitializeRequest> params, ::fidl::BytePart response_buffer);
+
+ // Free all trace buffers and any other resources allocated for the trace.
+ // This is also done when the connection is closed.
+ // Tracing is first stopped if not already stopped.
+ // May be called multiple times.
+ static ::fidl::DecodeResult<TerminateResponse> Terminate(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return the trace allocation configuration, if there is one.
+ static ::fidl::DecodeResult<GetAllocationResponse> GetAllocation(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Stage performance monitor specification for a cpu.
+ // Must be called with data collection off and after `Initialize()`.
+ // Note: This doesn't actually configure the h/w, this just stages
+ // the values for subsequent use by `Start()`.
+ static ::fidl::DecodeResult<StageConfigResponse> StageConfig(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<StageConfigRequest> params, ::fidl::BytePart response_buffer);
+
+ // Fetch performance monitor specification for a cpu, if it exists.
+ // Must be called with data collection off and after `StageConfig()`.
+ static ::fidl::DecodeResult<GetConfigResponse> GetConfig(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return a handle of a trace buffer, if it exists, and if `descriptor`
+ // is valid.
+ // `descriptor` is (0, 1, 2, ..., `num_buffers`-1)
+ static ::fidl::DecodeResult<GetBufferHandleResponse> GetBufferHandle(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetBufferHandleRequest> params, ::fidl::BytePart response_buffer);
+
+ // Turn on data collection.
+ // Must be called after `Initialize()` + `StageConfig()` and with data
+ // collection off.
+ static ::fidl::DecodeResult<StartResponse> Start(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Turn off data collection.
+ // May be called any time after `Initialize()` has been called and before
+ // `Terminate()`. If called at other times the call is ignored.
+ // May be called multiple times.
+ static ::fidl::DecodeResult<StopResponse> Stop(::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 = Controller;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetPropertiesCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::perfmon::cpu::Properties properties);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Properties properties);
+ void Reply(::fidl::DecodedMessage<GetPropertiesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPropertiesCompleter = ::fidl::Completer<GetPropertiesCompleterBase>;
+
+ virtual void GetProperties(GetPropertiesCompleter::Sync _completer) = 0;
+
+ class InitializeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<InitializeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using InitializeCompleter = ::fidl::Completer<InitializeCompleterBase>;
+
+ virtual void Initialize(::llcpp::fuchsia::perfmon::cpu::Allocation allocation, InitializeCompleter::Sync _completer) = 0;
+
+ class TerminateCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using TerminateCompleter = ::fidl::Completer<TerminateCompleterBase>;
+
+ virtual void Terminate(TerminateCompleter::Sync _completer) = 0;
+
+ class GetAllocationCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::perfmon::cpu::Allocation* allocation);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Allocation* allocation);
+ void Reply(::fidl::DecodedMessage<GetAllocationResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAllocationCompleter = ::fidl::Completer<GetAllocationCompleterBase>;
+
+ virtual void GetAllocation(GetAllocationCompleter::Sync _completer) = 0;
+
+ class StageConfigCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<StageConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StageConfigCompleter = ::fidl::Completer<StageConfigCompleterBase>;
+
+ virtual void StageConfig(::llcpp::fuchsia::perfmon::cpu::Config config, StageConfigCompleter::Sync _completer) = 0;
+
+ class GetConfigCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::perfmon::cpu::Config* config);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Config* config);
+ void Reply(::fidl::DecodedMessage<GetConfigResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetConfigCompleter = ::fidl::Completer<GetConfigCompleterBase>;
+
+ virtual void GetConfig(GetConfigCompleter::Sync _completer) = 0;
+
+ class GetBufferHandleCompleterBase : public _Base {
+ public:
+ void Reply(::zx::vmo vmo);
+ void Reply(::fidl::BytePart _buffer, ::zx::vmo vmo);
+ void Reply(::fidl::DecodedMessage<GetBufferHandleResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetBufferHandleCompleter = ::fidl::Completer<GetBufferHandleCompleterBase>;
+
+ virtual void GetBufferHandle(uint32_t descriptor, GetBufferHandleCompleter::Sync _completer) = 0;
+
+ class StartCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::perfmon::cpu::Controller_Start_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::perfmon::cpu::Controller_Start_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<StartResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StartCompleter = ::fidl::Completer<StartCompleterBase>;
+
+ virtual void Start(StartCompleter::Sync _completer) = 0;
+
+ class StopCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using StopCompleter = ::fidl::Completer<StopCompleterBase>;
+
+ virtual void Stop(StopCompleter::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 GetPropertiesRequest(const ::fidl::DecodedMessage<Controller::GetPropertiesRequest>& _msg);
+ static void GetPropertiesResponse(const ::fidl::DecodedMessage<Controller::GetPropertiesResponse>& _msg);
+ static void InitializeRequest(const ::fidl::DecodedMessage<Controller::InitializeRequest>& _msg);
+ static void InitializeResponse(const ::fidl::DecodedMessage<Controller::InitializeResponse>& _msg);
+ static void TerminateRequest(const ::fidl::DecodedMessage<Controller::TerminateRequest>& _msg);
+ static void TerminateResponse(const ::fidl::DecodedMessage<Controller::TerminateResponse>& _msg);
+ static void GetAllocationRequest(const ::fidl::DecodedMessage<Controller::GetAllocationRequest>& _msg);
+ static void GetAllocationResponse(const ::fidl::DecodedMessage<Controller::GetAllocationResponse>& _msg);
+ static void StageConfigRequest(const ::fidl::DecodedMessage<Controller::StageConfigRequest>& _msg);
+ static void StageConfigResponse(const ::fidl::DecodedMessage<Controller::StageConfigResponse>& _msg);
+ static void GetConfigRequest(const ::fidl::DecodedMessage<Controller::GetConfigRequest>& _msg);
+ static void GetConfigResponse(const ::fidl::DecodedMessage<Controller::GetConfigResponse>& _msg);
+ static void GetBufferHandleRequest(const ::fidl::DecodedMessage<Controller::GetBufferHandleRequest>& _msg);
+ static void GetBufferHandleResponse(const ::fidl::DecodedMessage<Controller::GetBufferHandleResponse>& _msg);
+ static void StartRequest(const ::fidl::DecodedMessage<Controller::StartRequest>& _msg);
+ static void StartResponse(const ::fidl::DecodedMessage<Controller::StartResponse>& _msg);
+ static void StopRequest(const ::fidl::DecodedMessage<Controller::StopRequest>& _msg);
+ static void StopResponse(const ::fidl::DecodedMessage<Controller::StopResponse>& _msg);
+ };
+};
+
+constexpr uint16_t API_VERSION = 0u;
+
+} // namespace cpu
+} // namespace perfmon
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::PropertyFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::PropertyFlags>);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::PropertyFlags) == sizeof(uint64_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Properties> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Properties>);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, api_version) == 0);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, pm_version) == 2);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, max_num_events) == 4);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, max_num_fixed_events) == 6);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, max_fixed_counter_width) == 8);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, max_num_programmable_events) == 10);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, max_programmable_counter_width) == 12);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, max_num_misc_events) == 14);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, max_misc_counter_width) == 16);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Properties, flags) == 24);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Properties) == ::llcpp::fuchsia::perfmon::cpu::Properties::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::EventConfigFlags> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::EventConfigFlags>);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::EventConfigFlags) == sizeof(uint32_t));
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::EventConfig> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::EventConfig>);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::EventConfig, event) == 0);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::EventConfig, rate) == 4);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::EventConfig, flags) == 8);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::EventConfig) == ::llcpp::fuchsia::perfmon::cpu::EventConfig::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Config> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Config>);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Config, events) == 0);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Config) == ::llcpp::fuchsia::perfmon::cpu::Config::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response>);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response) == ::llcpp::fuchsia::perfmon::cpu::Controller_Start_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller_Start_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Controller_Start_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response>);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response) == ::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Controller_StageConfig_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response>);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response) == ::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Controller_Initialize_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Allocation> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::perfmon::cpu::Allocation>);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Allocation, num_buffers) == 0);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Allocation, buffer_size_in_pages) == 4);
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Allocation) == ::llcpp::fuchsia::perfmon::cpu::Allocation::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::GetPropertiesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::GetPropertiesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::GetPropertiesResponse)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::GetPropertiesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::GetPropertiesResponse, properties) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::InitializeRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::InitializeRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::InitializeRequest)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::InitializeRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::InitializeRequest, allocation) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::InitializeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::InitializeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::InitializeResponse)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::InitializeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::InitializeResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::GetAllocationResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::GetAllocationResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::GetAllocationResponse)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::GetAllocationResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::GetAllocationResponse, allocation) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigRequest)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigRequest, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigResponse)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::StageConfigResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::GetConfigResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::GetConfigResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::GetConfigResponse)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::GetConfigResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::GetConfigResponse, config) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleRequest)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleRequest, descriptor) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleResponse)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::GetBufferHandleResponse, vmo) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::perfmon::cpu::Controller::StartResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::perfmon::cpu::Controller::StartResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::perfmon::cpu::Controller::StartResponse)
+ == ::llcpp::fuchsia::perfmon::cpu::Controller::StartResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::perfmon::cpu::Controller::StartResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-posix-socket/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-posix-socket/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..2c3c638
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-posix-socket/gen/llcpp/fidl.cc
@@ -0,0 +1,9555 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/posix/socket/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace posix {
+namespace socket {
+
+void ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(BaseSocket_GetSockOpt_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(BaseSocket_GetSockOpt_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(BaseSocket_GetSockOpt_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DatagramSocket_RecvMsg_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DatagramSocket_RecvMsg_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DatagramSocket_RecvMsg_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(BaseSocket_GetSockName_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(BaseSocket_GetSockName_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(BaseSocket_GetSockName_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(BaseSocket_GetPeerName_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(BaseSocket_GetPeerName_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(BaseSocket_GetPeerName_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(StreamSocket_Listen_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(StreamSocket_Listen_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(StreamSocket_Listen_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(StreamSocket_Accept_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(StreamSocket_Accept_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(StreamSocket_Accept_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::Provider_Socket2_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Provider_Socket2_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Provider_Socket2_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Provider_Socket2_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kProvider_Socket_Ordinal = 0x4d07378200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProvider_Socket_GenOrdinal = 0x3c53fd7d5afacab8lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ProviderSocketRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ProviderSocketResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kProvider_Socket2_Ordinal = 0x4d4cbf6100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProvider_Socket2_GenOrdinal = 0xafeae763c4a354lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ProviderSocket2RequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ProviderSocket2ResponseTable;
+
+} // namespace
+template <>
+Provider::ResultOf::Socket_Impl<Provider::SocketResponse>::Socket_Impl(::zx::unowned_channel _client_end, int16_t domain, int16_t type, int16_t protocol) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SocketRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SocketRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SocketRequest*>(_write_bytes);
+ _request.domain = std::move(domain);
+ _request.type = std::move(type);
+ _request.protocol = std::move(protocol);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SocketRequest));
+ ::fidl::DecodedMessage<SocketRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Provider::InPlace::Socket(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Provider::ResultOf::Socket Provider::SyncClient::Socket(int16_t domain, int16_t type, int16_t protocol) {
+ return ResultOf::Socket(::zx::unowned_channel(this->channel_), std::move(domain), std::move(type), std::move(protocol));
+}
+
+Provider::ResultOf::Socket Provider::Call::Socket(::zx::unowned_channel _client_end, int16_t domain, int16_t type, int16_t protocol) {
+ return ResultOf::Socket(std::move(_client_end), std::move(domain), std::move(type), std::move(protocol));
+}
+
+template <>
+Provider::UnownedResultOf::Socket_Impl<Provider::SocketResponse>::Socket_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SocketRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SocketResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SocketRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SocketRequest*>(_request_buffer.data());
+ _request.domain = std::move(domain);
+ _request.type = std::move(type);
+ _request.protocol = std::move(protocol);
+ _request_buffer.set_actual(sizeof(SocketRequest));
+ ::fidl::DecodedMessage<SocketRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Provider::InPlace::Socket(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Provider::UnownedResultOf::Socket Provider::SyncClient::Socket(::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Socket(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(domain), std::move(type), std::move(protocol), std::move(_response_buffer));
+}
+
+Provider::UnownedResultOf::Socket Provider::Call::Socket(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Socket(std::move(_client_end), std::move(_request_buffer), std::move(domain), std::move(type), std::move(protocol), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Provider::SocketResponse> Provider::InPlace::Socket(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SocketRequest> params, ::fidl::BytePart response_buffer) {
+ Provider::SetTransactionHeaderFor::SocketRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Provider::SocketResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SocketRequest, SocketResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Provider::SocketResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Provider::ResultOf::Socket2_Impl<Provider::Socket2Response>::Socket2_Impl(::zx::unowned_channel _client_end, int16_t domain, int16_t type, int16_t protocol) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<Socket2Request, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, Socket2Request::PrimarySize);
+ auto& _request = *reinterpret_cast<Socket2Request*>(_write_bytes);
+ _request.domain = std::move(domain);
+ _request.type = std::move(type);
+ _request.protocol = std::move(protocol);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(Socket2Request));
+ ::fidl::DecodedMessage<Socket2Request> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Provider::InPlace::Socket2(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Provider::ResultOf::Socket2 Provider::SyncClient::Socket2(int16_t domain, int16_t type, int16_t protocol) {
+ return ResultOf::Socket2(::zx::unowned_channel(this->channel_), std::move(domain), std::move(type), std::move(protocol));
+}
+
+Provider::ResultOf::Socket2 Provider::Call::Socket2(::zx::unowned_channel _client_end, int16_t domain, int16_t type, int16_t protocol) {
+ return ResultOf::Socket2(std::move(_client_end), std::move(domain), std::move(type), std::move(protocol));
+}
+
+template <>
+Provider::UnownedResultOf::Socket2_Impl<Provider::Socket2Response>::Socket2_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < Socket2Request::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<Socket2Response>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, Socket2Request::PrimarySize);
+ auto& _request = *reinterpret_cast<Socket2Request*>(_request_buffer.data());
+ _request.domain = std::move(domain);
+ _request.type = std::move(type);
+ _request.protocol = std::move(protocol);
+ _request_buffer.set_actual(sizeof(Socket2Request));
+ ::fidl::DecodedMessage<Socket2Request> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Provider::InPlace::Socket2(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Provider::UnownedResultOf::Socket2 Provider::SyncClient::Socket2(::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Socket2(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(domain), std::move(type), std::move(protocol), std::move(_response_buffer));
+}
+
+Provider::UnownedResultOf::Socket2 Provider::Call::Socket2(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Socket2(std::move(_client_end), std::move(_request_buffer), std::move(domain), std::move(type), std::move(protocol), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Provider::Socket2Response> Provider::InPlace::Socket2(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<Socket2Request> params, ::fidl::BytePart response_buffer) {
+ Provider::SetTransactionHeaderFor::Socket2Request(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Provider::Socket2Response>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<Socket2Request, Socket2Response>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Provider::Socket2Response>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Provider::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kProvider_Socket_Ordinal:
+ case kProvider_Socket_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SocketRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Socket(std::move(message->domain), std::move(message->type), std::move(message->protocol),
+ Interface::SocketCompleter::Sync(txn));
+ return true;
+ }
+ case kProvider_Socket2_Ordinal:
+ case kProvider_Socket2_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<Socket2Request>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Socket2(std::move(message->domain), std::move(message->type), std::move(message->protocol),
+ Interface::Socket2Completer::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Provider::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Provider::Interface::SocketCompleterBase::Reply(int16_t code, ::zx::channel s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SocketResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SocketResponse*>(_write_bytes);
+ Provider::SetTransactionHeaderFor::SocketResponse(
+ ::fidl::DecodedMessage<SocketResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SocketResponse::PrimarySize,
+ SocketResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SocketResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SocketResponse>(std::move(_response_bytes)));
+}
+
+void Provider::Interface::SocketCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code, ::zx::channel s) {
+ if (_buffer.capacity() < SocketResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SocketResponse*>(_buffer.data());
+ Provider::SetTransactionHeaderFor::SocketResponse(
+ ::fidl::DecodedMessage<SocketResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SocketResponse::PrimarySize,
+ SocketResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SocketResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SocketResponse>(std::move(_buffer)));
+}
+
+void Provider::Interface::SocketCompleterBase::Reply(::fidl::DecodedMessage<SocketResponse> params) {
+ Provider::SetTransactionHeaderFor::SocketResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Provider::Interface::Socket2CompleterBase::Reply(::llcpp::fuchsia::posix::socket::Provider_Socket2_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<Socket2Response, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ Socket2Response _response = {};
+ Provider::SetTransactionHeaderFor::Socket2Response(
+ ::fidl::DecodedMessage<Socket2Response>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ Socket2Response::PrimarySize,
+ Socket2Response::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Provider::Interface::Socket2CompleterBase::ReplySuccess(::zx::channel s) {
+ Provider_Socket2_Response response;
+ response.s = std::move(s);
+
+ Reply(Provider_Socket2_Result::WithResponse(&response));
+}
+void Provider::Interface::Socket2CompleterBase::ReplyError(int32_t error) {
+ Reply(Provider_Socket2_Result::WithErr(&error));
+}
+
+void Provider::Interface::Socket2CompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::Provider_Socket2_Result result) {
+ if (_buffer.capacity() < Socket2Response::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ Socket2Response _response = {};
+ Provider::SetTransactionHeaderFor::Socket2Response(
+ ::fidl::DecodedMessage<Socket2Response>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ Socket2Response::PrimarySize,
+ Socket2Response::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void Provider::Interface::Socket2CompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::channel s) {
+ Provider_Socket2_Response response;
+ response.s = std::move(s);
+
+ Reply(std::move(_buffer), Provider_Socket2_Result::WithResponse(&response));
+}
+
+void Provider::Interface::Socket2CompleterBase::Reply(::fidl::DecodedMessage<Socket2Response> params) {
+ Provider::SetTransactionHeaderFor::Socket2Response(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Provider::SetTransactionHeaderFor::SocketRequest(const ::fidl::DecodedMessage<Provider::SocketRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_Socket_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Provider::SetTransactionHeaderFor::SocketResponse(const ::fidl::DecodedMessage<Provider::SocketResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_Socket_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Provider::SetTransactionHeaderFor::Socket2Request(const ::fidl::DecodedMessage<Provider::Socket2Request>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_Socket2_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Provider::SetTransactionHeaderFor::Socket2Response(const ::fidl::DecodedMessage<Provider::Socket2Response>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_Socket2_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DatagramSocket_Shutdown_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DatagramSocket_Shutdown_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DatagramSocket_Shutdown_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(DatagramSocket_SendMsg_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(DatagramSocket_SendMsg_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(DatagramSocket_SendMsg_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(BaseSocket_SetSockOpt_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(BaseSocket_SetSockOpt_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(BaseSocket_SetSockOpt_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(BaseSocket_Connect_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(BaseSocket_Connect_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(BaseSocket_Connect_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(BaseSocket_Bind_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(BaseSocket_Bind_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(BaseSocket_Bind_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kControl_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_Bind_Ordinal = 0x147441ed00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_Bind_GenOrdinal = 0x369838aa5347aa8flu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlBindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_Connect_Ordinal = 0x237ed33800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_Connect_GenOrdinal = 0x1138f666cb3655b1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlConnectResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_Listen_Ordinal = 0x2e63628600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_Listen_GenOrdinal = 0xa860257383d5651lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlListenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlListenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_Accept_Ordinal = 0x11ed297300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_Accept_GenOrdinal = 0x17921a9ebebb7ba0lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlAcceptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlAcceptResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_GetSockName_Ordinal = 0x63c1368200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_GetSockName_GenOrdinal = 0x6f68e0f0d72c2d1dlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetSockNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetSockNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_GetPeerName_Ordinal = 0x58787bb600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_GetPeerName_GenOrdinal = 0x555a019c03d9820dlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetPeerNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetPeerNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_SetSockOpt_Ordinal = 0x4ba217a700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_SetSockOpt_GenOrdinal = 0x24e784a5e281b466lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSetSockOptResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControl_GetSockOpt_Ordinal = 0x3685367800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControl_GetSockOpt_GenOrdinal = 0x66298180e94aa6b4lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetSockOptResponseTable;
+
+} // namespace
+
+Control::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Control::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Control::ResultOf::Clone Control::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+Control::ResultOf::Clone Control::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+Control::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Control::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Control::UnownedResultOf::Clone Control::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+Control::UnownedResultOf::Clone Control::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError Control::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ Control::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+Control::ResultOf::Close_Impl<Control::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+Control::ResultOf::Close Control::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Control::ResultOf::Close Control::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+Control::UnownedResultOf::Close_Impl<Control::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::Close Control::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::Close Control::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::CloseResponse> Control::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Control::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::Describe_Impl<Control::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+Control::ResultOf::Describe Control::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+Control::ResultOf::Describe Control::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+Control::UnownedResultOf::Describe_Impl<Control::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::Describe Control::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::Describe Control::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::DescribeResponse> Control::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ Control::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::Sync_Impl<Control::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+Control::ResultOf::Sync Control::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+Control::ResultOf::Sync Control::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+Control::UnownedResultOf::Sync_Impl<Control::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::Sync Control::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::Sync Control::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::SyncResponse> Control::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ Control::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::GetAttr_Impl<Control::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+Control::ResultOf::GetAttr Control::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+Control::ResultOf::GetAttr Control::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+Control::UnownedResultOf::GetAttr_Impl<Control::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::GetAttr Control::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::GetAttr Control::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::GetAttrResponse> Control::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ Control::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::SetAttr_Impl<Control::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Control::ResultOf::SetAttr Control::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+Control::ResultOf::SetAttr Control::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+Control::UnownedResultOf::SetAttr_Impl<Control::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::SetAttr Control::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::SetAttr Control::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::SetAttrResponse> Control::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ Control::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::NodeGetFlags_Impl<Control::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+Control::ResultOf::NodeGetFlags Control::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+Control::ResultOf::NodeGetFlags Control::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+Control::UnownedResultOf::NodeGetFlags_Impl<Control::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::NodeGetFlags Control::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::NodeGetFlags Control::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::NodeGetFlagsResponse> Control::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ Control::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::NodeSetFlags_Impl<Control::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Control::ResultOf::NodeSetFlags Control::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Control::ResultOf::NodeSetFlags Control::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Control::UnownedResultOf::NodeSetFlags_Impl<Control::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::NodeSetFlags Control::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::NodeSetFlags Control::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::NodeSetFlagsResponse> Control::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ Control::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::Bind_Impl<Control::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ BindRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Control::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Control::ResultOf::Bind Control::SyncClient::Bind(::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+Control::ResultOf::Bind Control::Call::Bind(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Bind(std::move(_client_end), std::move(addr));
+}
+
+template <>
+Control::UnownedResultOf::Bind_Impl<Control::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BindRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BindResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ BindRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Control::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::Bind Control::SyncClient::Bind(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::Bind Control::Call::Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::BindResponse> Control::InPlace::Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer) {
+ Control::SetTransactionHeaderFor::BindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::BindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BindRequest, BindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::BindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::Connect_Impl<Control::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ConnectRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Control::InPlace::Connect(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Control::ResultOf::Connect Control::SyncClient::Connect(::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+Control::ResultOf::Connect Control::Call::Connect(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Connect(std::move(_client_end), std::move(addr));
+}
+
+template <>
+Control::UnownedResultOf::Connect_Impl<Control::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConnectRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConnectResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ ConnectRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Control::InPlace::Connect(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::Connect Control::SyncClient::Connect(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::Connect Control::Call::Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::ConnectResponse> Control::InPlace::Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params, ::fidl::BytePart response_buffer) {
+ Control::SetTransactionHeaderFor::ConnectRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::ConnectResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConnectRequest, ConnectResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::ConnectResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::Listen_Impl<Control::ListenResponse>::Listen_Impl(::zx::unowned_channel _client_end, int16_t backlog) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ListenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ListenRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ListenRequest*>(_write_bytes);
+ _request.backlog = std::move(backlog);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ListenRequest));
+ ::fidl::DecodedMessage<ListenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::Listen(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Control::ResultOf::Listen Control::SyncClient::Listen(int16_t backlog) {
+ return ResultOf::Listen(::zx::unowned_channel(this->channel_), std::move(backlog));
+}
+
+Control::ResultOf::Listen Control::Call::Listen(::zx::unowned_channel _client_end, int16_t backlog) {
+ return ResultOf::Listen(std::move(_client_end), std::move(backlog));
+}
+
+template <>
+Control::UnownedResultOf::Listen_Impl<Control::ListenResponse>::Listen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ListenRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ListenResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ListenRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ListenRequest*>(_request_buffer.data());
+ _request.backlog = std::move(backlog);
+ _request_buffer.set_actual(sizeof(ListenRequest));
+ ::fidl::DecodedMessage<ListenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::Listen(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::Listen Control::SyncClient::Listen(::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Listen(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(backlog), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::Listen Control::Call::Listen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Listen(std::move(_client_end), std::move(_request_buffer), std::move(backlog), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::ListenResponse> Control::InPlace::Listen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ListenRequest> params, ::fidl::BytePart response_buffer) {
+ Control::SetTransactionHeaderFor::ListenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::ListenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ListenRequest, ListenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::ListenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::Accept_Impl<Control::AcceptResponse>::Accept_Impl(::zx::unowned_channel _client_end, int16_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AcceptRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AcceptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AcceptRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AcceptRequest));
+ ::fidl::DecodedMessage<AcceptRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::Accept(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Control::ResultOf::Accept Control::SyncClient::Accept(int16_t flags) {
+ return ResultOf::Accept(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+Control::ResultOf::Accept Control::Call::Accept(::zx::unowned_channel _client_end, int16_t flags) {
+ return ResultOf::Accept(std::move(_client_end), std::move(flags));
+}
+
+template <>
+Control::UnownedResultOf::Accept_Impl<Control::AcceptResponse>::Accept_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AcceptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AcceptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AcceptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AcceptRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(AcceptRequest));
+ ::fidl::DecodedMessage<AcceptRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::Accept(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::Accept Control::SyncClient::Accept(::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Accept(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::Accept Control::Call::Accept(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Accept(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::AcceptResponse> Control::InPlace::Accept(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AcceptRequest> params, ::fidl::BytePart response_buffer) {
+ Control::SetTransactionHeaderFor::AcceptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::AcceptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AcceptRequest, AcceptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::AcceptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::GetSockName_Impl<Control::GetSockNameResponse>::GetSockName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSockNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSockNameRequest));
+ ::fidl::DecodedMessage<GetSockNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::GetSockName(std::move(_client_end), Super::response_buffer()));
+}
+
+Control::ResultOf::GetSockName Control::SyncClient::GetSockName() {
+ return ResultOf::GetSockName(::zx::unowned_channel(this->channel_));
+}
+
+Control::ResultOf::GetSockName Control::Call::GetSockName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetSockName(std::move(_client_end));
+}
+
+template <>
+Control::UnownedResultOf::GetSockName_Impl<Control::GetSockNameResponse>::GetSockName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetSockNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetSockNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetSockNameRequest));
+ ::fidl::DecodedMessage<GetSockNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::GetSockName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::GetSockName Control::SyncClient::GetSockName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::GetSockName Control::Call::GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::GetSockNameResponse> Control::InPlace::GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetSockNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetSockNameRequest> params(std::move(_request_buffer));
+ Control::SetTransactionHeaderFor::GetSockNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::GetSockNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSockNameRequest, GetSockNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::GetSockNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::GetPeerName_Impl<Control::GetPeerNameResponse>::GetPeerName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPeerNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPeerNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPeerNameRequest));
+ ::fidl::DecodedMessage<GetPeerNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::GetPeerName(std::move(_client_end), Super::response_buffer()));
+}
+
+Control::ResultOf::GetPeerName Control::SyncClient::GetPeerName() {
+ return ResultOf::GetPeerName(::zx::unowned_channel(this->channel_));
+}
+
+Control::ResultOf::GetPeerName Control::Call::GetPeerName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetPeerName(std::move(_client_end));
+}
+
+template <>
+Control::UnownedResultOf::GetPeerName_Impl<Control::GetPeerNameResponse>::GetPeerName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPeerNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPeerNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPeerNameRequest));
+ ::fidl::DecodedMessage<GetPeerNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::GetPeerName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::GetPeerName Control::SyncClient::GetPeerName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPeerName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::GetPeerName Control::Call::GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPeerName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::GetPeerNameResponse> Control::InPlace::GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPeerNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPeerNameRequest> params(std::move(_request_buffer));
+ Control::SetTransactionHeaderFor::GetPeerNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::GetPeerNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPeerNameRequest, GetPeerNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::GetPeerNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::SetSockOpt_Impl<Control::SetSockOptResponse>::SetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSockOptRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetSockOptRequest _request = {};
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetSockOptRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Control::InPlace::SetSockOpt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Control::ResultOf::SetSockOpt Control::SyncClient::SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ return ResultOf::SetSockOpt(::zx::unowned_channel(this->channel_), std::move(level), std::move(optname), std::move(optval));
+}
+
+Control::ResultOf::SetSockOpt Control::Call::SetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ return ResultOf::SetSockOpt(std::move(_client_end), std::move(level), std::move(optname), std::move(optval));
+}
+
+template <>
+Control::UnownedResultOf::SetSockOpt_Impl<Control::SetSockOptResponse>::SetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetSockOptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetSockOptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetSockOptRequest _request = {};
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetSockOptRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Control::InPlace::SetSockOpt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::SetSockOpt Control::SyncClient::SetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSockOpt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(level), std::move(optname), std::move(optval), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::SetSockOpt Control::Call::SetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSockOpt(std::move(_client_end), std::move(_request_buffer), std::move(level), std::move(optname), std::move(optval), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::SetSockOptResponse> Control::InPlace::SetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSockOptRequest> params, ::fidl::BytePart response_buffer) {
+ Control::SetTransactionHeaderFor::SetSockOptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::SetSockOptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetSockOptRequest, SetSockOptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::SetSockOptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Control::ResultOf::GetSockOpt_Impl<Control::GetSockOptResponse>::GetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockOptRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSockOptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSockOptRequest*>(_write_bytes);
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSockOptRequest));
+ ::fidl::DecodedMessage<GetSockOptRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Control::InPlace::GetSockOpt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Control::ResultOf::GetSockOpt Control::SyncClient::GetSockOpt(int16_t level, int16_t optname) {
+ return ResultOf::GetSockOpt(::zx::unowned_channel(this->channel_), std::move(level), std::move(optname));
+}
+
+Control::ResultOf::GetSockOpt Control::Call::GetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname) {
+ return ResultOf::GetSockOpt(std::move(_client_end), std::move(level), std::move(optname));
+}
+
+template <>
+Control::UnownedResultOf::GetSockOpt_Impl<Control::GetSockOptResponse>::GetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetSockOptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetSockOptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetSockOptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSockOptRequest*>(_request_buffer.data());
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request_buffer.set_actual(sizeof(GetSockOptRequest));
+ ::fidl::DecodedMessage<GetSockOptRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Control::InPlace::GetSockOpt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Control::UnownedResultOf::GetSockOpt Control::SyncClient::GetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockOpt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(level), std::move(optname), std::move(_response_buffer));
+}
+
+Control::UnownedResultOf::GetSockOpt Control::Call::GetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockOpt(std::move(_client_end), std::move(_request_buffer), std::move(level), std::move(optname), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Control::GetSockOptResponse> Control::InPlace::GetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSockOptRequest> params, ::fidl::BytePart response_buffer) {
+ Control::SetTransactionHeaderFor::GetSockOptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::GetSockOptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSockOptRequest, GetSockOptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Control::GetSockOptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t Control::SyncClient::HandleEvents(Control::EventHandlers handlers) {
+ return Control::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t Control::Call::HandleEvents(::zx::unowned_channel client_end, Control::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kControl_OnOpen_Ordinal:
+ case kControl_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool Control::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kControl_Clone_Ordinal:
+ case kControl_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_Close_Ordinal:
+ case kControl_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_Describe_Ordinal:
+ case kControl_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_Sync_Ordinal:
+ case kControl_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_GetAttr_Ordinal:
+ case kControl_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_SetAttr_Ordinal:
+ case kControl_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_NodeGetFlags_Ordinal:
+ case kControl_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_NodeSetFlags_Ordinal:
+ case kControl_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_Bind_Ordinal:
+ case kControl_Bind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Bind(std::move(message->addr),
+ Interface::BindCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_Connect_Ordinal:
+ case kControl_Connect_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConnectRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Connect(std::move(message->addr),
+ Interface::ConnectCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_Listen_Ordinal:
+ case kControl_Listen_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ListenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Listen(std::move(message->backlog),
+ Interface::ListenCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_Accept_Ordinal:
+ case kControl_Accept_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AcceptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Accept(std::move(message->flags),
+ Interface::AcceptCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_GetSockName_Ordinal:
+ case kControl_GetSockName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSockNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetSockName(
+ Interface::GetSockNameCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_GetPeerName_Ordinal:
+ case kControl_GetPeerName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPeerNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetPeerName(
+ Interface::GetPeerNameCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_SetSockOpt_Ordinal:
+ case kControl_SetSockOpt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetSockOptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetSockOpt(std::move(message->level), std::move(message->optname), std::move(message->optval),
+ Interface::SetSockOptCompleter::Sync(txn));
+ return true;
+ }
+ case kControl_GetSockOpt_Ordinal:
+ case kControl_GetSockOpt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSockOptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetSockOpt(std::move(message->level), std::move(message->optname),
+ Interface::GetSockOptCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Control::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Control::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ Control::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ Control::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Control::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ Control::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Control::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ Control::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t Control::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ Control::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Control::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ Control::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t Control::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ Control::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void Control::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ Control::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ Control::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ Control::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ Control::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ Control::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::BindCompleterBase::Reply(int16_t code) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<BindResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.code = std::move(code);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(BindResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<BindResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::BindCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code) {
+ if (_buffer.capacity() < BindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<BindResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _buffer.set_actual(sizeof(BindResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<BindResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::BindCompleterBase::Reply(::fidl::DecodedMessage<BindResponse> params) {
+ Control::SetTransactionHeaderFor::BindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::ConnectCompleterBase::Reply(int16_t code) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConnectResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.code = std::move(code);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConnectResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConnectResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::ConnectCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code) {
+ if (_buffer.capacity() < ConnectResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConnectResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _buffer.set_actual(sizeof(ConnectResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConnectResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::ConnectCompleterBase::Reply(::fidl::DecodedMessage<ConnectResponse> params) {
+ Control::SetTransactionHeaderFor::ConnectResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::ListenCompleterBase::Reply(int16_t code) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ListenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ListenResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::ListenResponse(
+ ::fidl::DecodedMessage<ListenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ListenResponse::PrimarySize,
+ ListenResponse::PrimarySize)));
+ _response.code = std::move(code);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ListenResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ListenResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::ListenCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code) {
+ if (_buffer.capacity() < ListenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ListenResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::ListenResponse(
+ ::fidl::DecodedMessage<ListenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ListenResponse::PrimarySize,
+ ListenResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _buffer.set_actual(sizeof(ListenResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ListenResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::ListenCompleterBase::Reply(::fidl::DecodedMessage<ListenResponse> params) {
+ Control::SetTransactionHeaderFor::ListenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::AcceptCompleterBase::Reply(int16_t code, ::zx::channel s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AcceptResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<AcceptResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::AcceptResponse(
+ ::fidl::DecodedMessage<AcceptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AcceptResponse::PrimarySize,
+ AcceptResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AcceptResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<AcceptResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::AcceptCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code, ::zx::channel s) {
+ if (_buffer.capacity() < AcceptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<AcceptResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::AcceptResponse(
+ ::fidl::DecodedMessage<AcceptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AcceptResponse::PrimarySize,
+ AcceptResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(AcceptResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<AcceptResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::AcceptCompleterBase::Reply(::fidl::DecodedMessage<AcceptResponse> params) {
+ Control::SetTransactionHeaderFor::AcceptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::GetSockNameCompleterBase::Reply(int16_t code, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetSockNameResponse _response = {};
+ Control::SetTransactionHeaderFor::GetSockNameResponse(
+ ::fidl::DecodedMessage<GetSockNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockNameResponse::PrimarySize,
+ GetSockNameResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Control::Interface::GetSockNameCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code, ::fidl::VectorView<uint8_t> addr) {
+ if (_buffer.capacity() < GetSockNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSockNameResponse _response = {};
+ Control::SetTransactionHeaderFor::GetSockNameResponse(
+ ::fidl::DecodedMessage<GetSockNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockNameResponse::PrimarySize,
+ GetSockNameResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Control::Interface::GetSockNameCompleterBase::Reply(::fidl::DecodedMessage<GetSockNameResponse> params) {
+ Control::SetTransactionHeaderFor::GetSockNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::GetPeerNameCompleterBase::Reply(int16_t code, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPeerNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetPeerNameResponse _response = {};
+ Control::SetTransactionHeaderFor::GetPeerNameResponse(
+ ::fidl::DecodedMessage<GetPeerNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPeerNameResponse::PrimarySize,
+ GetPeerNameResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Control::Interface::GetPeerNameCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code, ::fidl::VectorView<uint8_t> addr) {
+ if (_buffer.capacity() < GetPeerNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPeerNameResponse _response = {};
+ Control::SetTransactionHeaderFor::GetPeerNameResponse(
+ ::fidl::DecodedMessage<GetPeerNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPeerNameResponse::PrimarySize,
+ GetPeerNameResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Control::Interface::GetPeerNameCompleterBase::Reply(::fidl::DecodedMessage<GetPeerNameResponse> params) {
+ Control::SetTransactionHeaderFor::GetPeerNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::SetSockOptCompleterBase::Reply(int16_t code) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSockOptResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetSockOptResponse*>(_write_bytes);
+ Control::SetTransactionHeaderFor::SetSockOptResponse(
+ ::fidl::DecodedMessage<SetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSockOptResponse::PrimarySize,
+ SetSockOptResponse::PrimarySize)));
+ _response.code = std::move(code);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetSockOptResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetSockOptResponse>(std::move(_response_bytes)));
+}
+
+void Control::Interface::SetSockOptCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code) {
+ if (_buffer.capacity() < SetSockOptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetSockOptResponse*>(_buffer.data());
+ Control::SetTransactionHeaderFor::SetSockOptResponse(
+ ::fidl::DecodedMessage<SetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSockOptResponse::PrimarySize,
+ SetSockOptResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _buffer.set_actual(sizeof(SetSockOptResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetSockOptResponse>(std::move(_buffer)));
+}
+
+void Control::Interface::SetSockOptCompleterBase::Reply(::fidl::DecodedMessage<SetSockOptResponse> params) {
+ Control::SetTransactionHeaderFor::SetSockOptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Control::Interface::GetSockOptCompleterBase::Reply(int16_t code, ::fidl::VectorView<uint8_t> optval) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockOptResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetSockOptResponse _response = {};
+ Control::SetTransactionHeaderFor::GetSockOptResponse(
+ ::fidl::DecodedMessage<GetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockOptResponse::PrimarySize,
+ GetSockOptResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Control::Interface::GetSockOptCompleterBase::Reply(::fidl::BytePart _buffer, int16_t code, ::fidl::VectorView<uint8_t> optval) {
+ if (_buffer.capacity() < GetSockOptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSockOptResponse _response = {};
+ Control::SetTransactionHeaderFor::GetSockOptResponse(
+ ::fidl::DecodedMessage<GetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockOptResponse::PrimarySize,
+ GetSockOptResponse::PrimarySize)));
+ _response.code = std::move(code);
+ _response.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Control::Interface::GetSockOptCompleterBase::Reply(::fidl::DecodedMessage<GetSockOptResponse> params) {
+ Control::SetTransactionHeaderFor::GetSockOptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Control::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<Control::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Control::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<Control::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<Control::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<Control::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<Control::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<Control::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<Control::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<Control::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<Control::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<Control::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<Control::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<Control::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<Control::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<Control::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<Control::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::BindRequest(const ::fidl::DecodedMessage<Control::BindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::BindResponse(const ::fidl::DecodedMessage<Control::BindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::ConnectRequest(const ::fidl::DecodedMessage<Control::ConnectRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::ConnectResponse(const ::fidl::DecodedMessage<Control::ConnectResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::ListenRequest(const ::fidl::DecodedMessage<Control::ListenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Listen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::ListenResponse(const ::fidl::DecodedMessage<Control::ListenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Listen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::AcceptRequest(const ::fidl::DecodedMessage<Control::AcceptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Accept_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::AcceptResponse(const ::fidl::DecodedMessage<Control::AcceptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_Accept_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::GetSockNameRequest(const ::fidl::DecodedMessage<Control::GetSockNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_GetSockName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::GetSockNameResponse(const ::fidl::DecodedMessage<Control::GetSockNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_GetSockName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::GetPeerNameRequest(const ::fidl::DecodedMessage<Control::GetPeerNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_GetPeerName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::GetPeerNameResponse(const ::fidl::DecodedMessage<Control::GetPeerNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_GetPeerName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::SetSockOptRequest(const ::fidl::DecodedMessage<Control::SetSockOptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_SetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::SetSockOptResponse(const ::fidl::DecodedMessage<Control::SetSockOptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_SetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Control::SetTransactionHeaderFor::GetSockOptRequest(const ::fidl::DecodedMessage<Control::GetSockOptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_GetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Control::SetTransactionHeaderFor::GetSockOptResponse(const ::fidl::DecodedMessage<Control::GetSockOptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControl_GetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Bind_Ordinal = 0x11ebbc3c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Bind_GenOrdinal = 0xf8457e6b05e15bclu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketBindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Connect_Ordinal = 0x62cb94300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_Connect_GenOrdinal = 0x17abeee0b9843bb1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketConnectResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_GetSockName_Ordinal = 0x7c14255c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_GetSockName_GenOrdinal = 0x41a618ef19a91f9dlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetSockNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetSockNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_GetPeerName_Ordinal = 0x4beee9b000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_GetPeerName_GenOrdinal = 0x4009d08a4beb5e95lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetPeerNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetPeerNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_SetSockOpt_Ordinal = 0x497c444100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_SetSockOpt_GenOrdinal = 0x93c6f802203e6f1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSetSockOptResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_GetSockOpt_Ordinal = 0x3b2b8b3d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBaseSocket_GetSockOpt_GenOrdinal = 0x6dfaf70f0ed40544lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetSockOptResponseTable;
+
+} // namespace
+
+BaseSocket::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BaseSocket::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BaseSocket::ResultOf::Clone BaseSocket::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+BaseSocket::ResultOf::Clone BaseSocket::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+BaseSocket::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BaseSocket::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BaseSocket::UnownedResultOf::Clone BaseSocket::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+BaseSocket::UnownedResultOf::Clone BaseSocket::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError BaseSocket::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ BaseSocket::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+BaseSocket::ResultOf::Close_Impl<BaseSocket::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::Close BaseSocket::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+BaseSocket::ResultOf::Close BaseSocket::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+BaseSocket::UnownedResultOf::Close_Impl<BaseSocket::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::Close BaseSocket::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::Close BaseSocket::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::CloseResponse> BaseSocket::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ BaseSocket::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::Describe_Impl<BaseSocket::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::Describe BaseSocket::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+BaseSocket::ResultOf::Describe BaseSocket::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+BaseSocket::UnownedResultOf::Describe_Impl<BaseSocket::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::Describe BaseSocket::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::Describe BaseSocket::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::DescribeResponse> BaseSocket::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ BaseSocket::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::Sync_Impl<BaseSocket::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::Sync BaseSocket::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+BaseSocket::ResultOf::Sync BaseSocket::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+BaseSocket::UnownedResultOf::Sync_Impl<BaseSocket::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::Sync BaseSocket::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::Sync BaseSocket::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::SyncResponse> BaseSocket::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ BaseSocket::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::GetAttr_Impl<BaseSocket::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::GetAttr BaseSocket::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+BaseSocket::ResultOf::GetAttr BaseSocket::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+BaseSocket::UnownedResultOf::GetAttr_Impl<BaseSocket::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::GetAttr BaseSocket::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::GetAttr BaseSocket::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::GetAttrResponse> BaseSocket::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ BaseSocket::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::SetAttr_Impl<BaseSocket::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::SetAttr BaseSocket::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+BaseSocket::ResultOf::SetAttr BaseSocket::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+BaseSocket::UnownedResultOf::SetAttr_Impl<BaseSocket::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::SetAttr BaseSocket::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::SetAttr BaseSocket::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::SetAttrResponse> BaseSocket::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ BaseSocket::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::NodeGetFlags_Impl<BaseSocket::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::NodeGetFlags BaseSocket::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+BaseSocket::ResultOf::NodeGetFlags BaseSocket::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+BaseSocket::UnownedResultOf::NodeGetFlags_Impl<BaseSocket::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::NodeGetFlags BaseSocket::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::NodeGetFlags BaseSocket::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::NodeGetFlagsResponse> BaseSocket::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ BaseSocket::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::NodeSetFlags_Impl<BaseSocket::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::NodeSetFlags BaseSocket::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+BaseSocket::ResultOf::NodeSetFlags BaseSocket::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+BaseSocket::UnownedResultOf::NodeSetFlags_Impl<BaseSocket::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::NodeSetFlags BaseSocket::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::NodeSetFlags BaseSocket::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::NodeSetFlagsResponse> BaseSocket::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ BaseSocket::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::Bind_Impl<BaseSocket::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ BindRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ BaseSocket::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::Bind BaseSocket::SyncClient::Bind(::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+BaseSocket::ResultOf::Bind BaseSocket::Call::Bind(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Bind(std::move(_client_end), std::move(addr));
+}
+
+template <>
+BaseSocket::UnownedResultOf::Bind_Impl<BaseSocket::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BindRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BindResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ BindRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ BaseSocket::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::Bind BaseSocket::SyncClient::Bind(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::Bind BaseSocket::Call::Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::BindResponse> BaseSocket::InPlace::Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer) {
+ BaseSocket::SetTransactionHeaderFor::BindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::BindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BindRequest, BindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::BindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::Connect_Impl<BaseSocket::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ConnectRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ BaseSocket::InPlace::Connect(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::Connect BaseSocket::SyncClient::Connect(::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+BaseSocket::ResultOf::Connect BaseSocket::Call::Connect(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Connect(std::move(_client_end), std::move(addr));
+}
+
+template <>
+BaseSocket::UnownedResultOf::Connect_Impl<BaseSocket::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConnectRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConnectResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ ConnectRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ BaseSocket::InPlace::Connect(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::Connect BaseSocket::SyncClient::Connect(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::Connect BaseSocket::Call::Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::ConnectResponse> BaseSocket::InPlace::Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params, ::fidl::BytePart response_buffer) {
+ BaseSocket::SetTransactionHeaderFor::ConnectRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::ConnectResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConnectRequest, ConnectResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::ConnectResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::GetSockName_Impl<BaseSocket::GetSockNameResponse>::GetSockName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSockNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSockNameRequest));
+ ::fidl::DecodedMessage<GetSockNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::GetSockName(std::move(_client_end), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::GetSockName BaseSocket::SyncClient::GetSockName() {
+ return ResultOf::GetSockName(::zx::unowned_channel(this->channel_));
+}
+
+BaseSocket::ResultOf::GetSockName BaseSocket::Call::GetSockName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetSockName(std::move(_client_end));
+}
+
+template <>
+BaseSocket::UnownedResultOf::GetSockName_Impl<BaseSocket::GetSockNameResponse>::GetSockName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetSockNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetSockNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetSockNameRequest));
+ ::fidl::DecodedMessage<GetSockNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::GetSockName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::GetSockName BaseSocket::SyncClient::GetSockName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::GetSockName BaseSocket::Call::GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::GetSockNameResponse> BaseSocket::InPlace::GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetSockNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetSockNameRequest> params(std::move(_request_buffer));
+ BaseSocket::SetTransactionHeaderFor::GetSockNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::GetSockNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSockNameRequest, GetSockNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::GetSockNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::GetPeerName_Impl<BaseSocket::GetPeerNameResponse>::GetPeerName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPeerNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPeerNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPeerNameRequest));
+ ::fidl::DecodedMessage<GetPeerNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::GetPeerName(std::move(_client_end), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::GetPeerName BaseSocket::SyncClient::GetPeerName() {
+ return ResultOf::GetPeerName(::zx::unowned_channel(this->channel_));
+}
+
+BaseSocket::ResultOf::GetPeerName BaseSocket::Call::GetPeerName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetPeerName(std::move(_client_end));
+}
+
+template <>
+BaseSocket::UnownedResultOf::GetPeerName_Impl<BaseSocket::GetPeerNameResponse>::GetPeerName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPeerNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPeerNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPeerNameRequest));
+ ::fidl::DecodedMessage<GetPeerNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::GetPeerName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::GetPeerName BaseSocket::SyncClient::GetPeerName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPeerName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::GetPeerName BaseSocket::Call::GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPeerName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::GetPeerNameResponse> BaseSocket::InPlace::GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPeerNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPeerNameRequest> params(std::move(_request_buffer));
+ BaseSocket::SetTransactionHeaderFor::GetPeerNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::GetPeerNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPeerNameRequest, GetPeerNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::GetPeerNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::SetSockOpt_Impl<BaseSocket::SetSockOptResponse>::SetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSockOptRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetSockOptRequest _request = {};
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetSockOptRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ BaseSocket::InPlace::SetSockOpt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::SetSockOpt BaseSocket::SyncClient::SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ return ResultOf::SetSockOpt(::zx::unowned_channel(this->channel_), std::move(level), std::move(optname), std::move(optval));
+}
+
+BaseSocket::ResultOf::SetSockOpt BaseSocket::Call::SetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ return ResultOf::SetSockOpt(std::move(_client_end), std::move(level), std::move(optname), std::move(optval));
+}
+
+template <>
+BaseSocket::UnownedResultOf::SetSockOpt_Impl<BaseSocket::SetSockOptResponse>::SetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetSockOptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetSockOptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetSockOptRequest _request = {};
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetSockOptRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ BaseSocket::InPlace::SetSockOpt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::SetSockOpt BaseSocket::SyncClient::SetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSockOpt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(level), std::move(optname), std::move(optval), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::SetSockOpt BaseSocket::Call::SetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSockOpt(std::move(_client_end), std::move(_request_buffer), std::move(level), std::move(optname), std::move(optval), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::SetSockOptResponse> BaseSocket::InPlace::SetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSockOptRequest> params, ::fidl::BytePart response_buffer) {
+ BaseSocket::SetTransactionHeaderFor::SetSockOptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::SetSockOptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetSockOptRequest, SetSockOptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::SetSockOptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BaseSocket::ResultOf::GetSockOpt_Impl<BaseSocket::GetSockOptResponse>::GetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockOptRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSockOptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSockOptRequest*>(_write_bytes);
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSockOptRequest));
+ ::fidl::DecodedMessage<GetSockOptRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BaseSocket::InPlace::GetSockOpt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BaseSocket::ResultOf::GetSockOpt BaseSocket::SyncClient::GetSockOpt(int16_t level, int16_t optname) {
+ return ResultOf::GetSockOpt(::zx::unowned_channel(this->channel_), std::move(level), std::move(optname));
+}
+
+BaseSocket::ResultOf::GetSockOpt BaseSocket::Call::GetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname) {
+ return ResultOf::GetSockOpt(std::move(_client_end), std::move(level), std::move(optname));
+}
+
+template <>
+BaseSocket::UnownedResultOf::GetSockOpt_Impl<BaseSocket::GetSockOptResponse>::GetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetSockOptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetSockOptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetSockOptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSockOptRequest*>(_request_buffer.data());
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request_buffer.set_actual(sizeof(GetSockOptRequest));
+ ::fidl::DecodedMessage<GetSockOptRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BaseSocket::InPlace::GetSockOpt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BaseSocket::UnownedResultOf::GetSockOpt BaseSocket::SyncClient::GetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockOpt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(level), std::move(optname), std::move(_response_buffer));
+}
+
+BaseSocket::UnownedResultOf::GetSockOpt BaseSocket::Call::GetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockOpt(std::move(_client_end), std::move(_request_buffer), std::move(level), std::move(optname), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BaseSocket::GetSockOptResponse> BaseSocket::InPlace::GetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSockOptRequest> params, ::fidl::BytePart response_buffer) {
+ BaseSocket::SetTransactionHeaderFor::GetSockOptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::GetSockOptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSockOptRequest, GetSockOptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BaseSocket::GetSockOptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t BaseSocket::SyncClient::HandleEvents(BaseSocket::EventHandlers handlers) {
+ return BaseSocket::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t BaseSocket::Call::HandleEvents(::zx::unowned_channel client_end, BaseSocket::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kBaseSocket_OnOpen_Ordinal:
+ case kBaseSocket_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool BaseSocket::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBaseSocket_Clone_Ordinal:
+ case kBaseSocket_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_Close_Ordinal:
+ case kBaseSocket_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_Describe_Ordinal:
+ case kBaseSocket_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_Sync_Ordinal:
+ case kBaseSocket_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_GetAttr_Ordinal:
+ case kBaseSocket_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_SetAttr_Ordinal:
+ case kBaseSocket_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_NodeGetFlags_Ordinal:
+ case kBaseSocket_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_NodeSetFlags_Ordinal:
+ case kBaseSocket_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_Bind_Ordinal:
+ case kBaseSocket_Bind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Bind(std::move(message->addr),
+ Interface::BindCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_Connect_Ordinal:
+ case kBaseSocket_Connect_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConnectRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Connect(std::move(message->addr),
+ Interface::ConnectCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_GetSockName_Ordinal:
+ case kBaseSocket_GetSockName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSockNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetSockName(
+ Interface::GetSockNameCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_GetPeerName_Ordinal:
+ case kBaseSocket_GetPeerName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPeerNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetPeerName(
+ Interface::GetPeerNameCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_SetSockOpt_Ordinal:
+ case kBaseSocket_SetSockOpt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetSockOptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetSockOpt(std::move(message->level), std::move(message->optname), std::move(message->optval),
+ Interface::SetSockOptCompleter::Sync(txn));
+ return true;
+ }
+ case kBaseSocket_GetSockOpt_Ordinal:
+ case kBaseSocket_GetSockOpt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSockOptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetSockOpt(std::move(message->level), std::move(message->optname),
+ Interface::GetSockOptCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool BaseSocket::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void BaseSocket::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ BaseSocket::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void BaseSocket::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ BaseSocket::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void BaseSocket::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void BaseSocket::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void BaseSocket::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t BaseSocket::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t BaseSocket::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t BaseSocket::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void BaseSocket::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ BaseSocket::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void BaseSocket::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ BaseSocket::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void BaseSocket::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ BaseSocket::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void BaseSocket::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ BaseSocket::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void BaseSocket::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ BaseSocket::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void BaseSocket::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ BaseSocket::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void BaseSocket::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ BaseSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void BaseSocket::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ BaseSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void BaseSocket::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ BaseSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void BaseSocket::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ BaseSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void BaseSocket::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::BindCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ BindResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::BindCompleterBase::ReplySuccess() {
+ BaseSocket_Bind_Response response;
+
+ Reply(BaseSocket_Bind_Result::WithResponse(&response));
+}
+void BaseSocket::Interface::BindCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_Bind_Result::WithErr(&error));
+}
+
+void BaseSocket::Interface::BindCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result) {
+ if (_buffer.capacity() < BindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ BindResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::BindCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_Bind_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_Bind_Result::WithResponse(&response));
+}
+
+void BaseSocket::Interface::BindCompleterBase::Reply(::fidl::DecodedMessage<BindResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::BindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::ConnectCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ConnectResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::ConnectCompleterBase::ReplySuccess() {
+ BaseSocket_Connect_Response response;
+
+ Reply(BaseSocket_Connect_Result::WithResponse(&response));
+}
+void BaseSocket::Interface::ConnectCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_Connect_Result::WithErr(&error));
+}
+
+void BaseSocket::Interface::ConnectCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result) {
+ if (_buffer.capacity() < ConnectResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ConnectResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::ConnectCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_Connect_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_Connect_Result::WithResponse(&response));
+}
+
+void BaseSocket::Interface::ConnectCompleterBase::Reply(::fidl::DecodedMessage<ConnectResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::ConnectResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::GetSockNameCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetSockNameResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::GetSockNameResponse(
+ ::fidl::DecodedMessage<GetSockNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockNameResponse::PrimarySize,
+ GetSockNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::GetSockNameCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetSockName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(BaseSocket_GetSockName_Result::WithResponse(&response));
+}
+void BaseSocket::Interface::GetSockNameCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetSockName_Result::WithErr(&error));
+}
+
+void BaseSocket::Interface::GetSockNameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result) {
+ if (_buffer.capacity() < GetSockNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSockNameResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::GetSockNameResponse(
+ ::fidl::DecodedMessage<GetSockNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockNameResponse::PrimarySize,
+ GetSockNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::GetSockNameCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetSockName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(std::move(_buffer), BaseSocket_GetSockName_Result::WithResponse(&response));
+}
+
+void BaseSocket::Interface::GetSockNameCompleterBase::Reply(::fidl::DecodedMessage<GetSockNameResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::GetSockNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::GetPeerNameCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPeerNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetPeerNameResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::GetPeerNameResponse(
+ ::fidl::DecodedMessage<GetPeerNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPeerNameResponse::PrimarySize,
+ GetPeerNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::GetPeerNameCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetPeerName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(BaseSocket_GetPeerName_Result::WithResponse(&response));
+}
+void BaseSocket::Interface::GetPeerNameCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetPeerName_Result::WithErr(&error));
+}
+
+void BaseSocket::Interface::GetPeerNameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result) {
+ if (_buffer.capacity() < GetPeerNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPeerNameResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::GetPeerNameResponse(
+ ::fidl::DecodedMessage<GetPeerNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPeerNameResponse::PrimarySize,
+ GetPeerNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::GetPeerNameCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetPeerName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(std::move(_buffer), BaseSocket_GetPeerName_Result::WithResponse(&response));
+}
+
+void BaseSocket::Interface::GetPeerNameCompleterBase::Reply(::fidl::DecodedMessage<GetPeerNameResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::GetPeerNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::SetSockOptCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSockOptResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SetSockOptResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::SetSockOptResponse(
+ ::fidl::DecodedMessage<SetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSockOptResponse::PrimarySize,
+ SetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::SetSockOptCompleterBase::ReplySuccess() {
+ BaseSocket_SetSockOpt_Response response;
+
+ Reply(BaseSocket_SetSockOpt_Result::WithResponse(&response));
+}
+void BaseSocket::Interface::SetSockOptCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_SetSockOpt_Result::WithErr(&error));
+}
+
+void BaseSocket::Interface::SetSockOptCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result) {
+ if (_buffer.capacity() < SetSockOptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SetSockOptResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::SetSockOptResponse(
+ ::fidl::DecodedMessage<SetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSockOptResponse::PrimarySize,
+ SetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::SetSockOptCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_SetSockOpt_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_SetSockOpt_Result::WithResponse(&response));
+}
+
+void BaseSocket::Interface::SetSockOptCompleterBase::Reply(::fidl::DecodedMessage<SetSockOptResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::SetSockOptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BaseSocket::Interface::GetSockOptCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockOptResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetSockOptResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::GetSockOptResponse(
+ ::fidl::DecodedMessage<GetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockOptResponse::PrimarySize,
+ GetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::GetSockOptCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> optval) {
+ BaseSocket_GetSockOpt_Response response;
+ response.optval = std::move(optval);
+
+ Reply(BaseSocket_GetSockOpt_Result::WithResponse(&response));
+}
+void BaseSocket::Interface::GetSockOptCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetSockOpt_Result::WithErr(&error));
+}
+
+void BaseSocket::Interface::GetSockOptCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result) {
+ if (_buffer.capacity() < GetSockOptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSockOptResponse _response = {};
+ BaseSocket::SetTransactionHeaderFor::GetSockOptResponse(
+ ::fidl::DecodedMessage<GetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockOptResponse::PrimarySize,
+ GetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void BaseSocket::Interface::GetSockOptCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> optval) {
+ BaseSocket_GetSockOpt_Response response;
+ response.optval = std::move(optval);
+
+ Reply(std::move(_buffer), BaseSocket_GetSockOpt_Result::WithResponse(&response));
+}
+
+void BaseSocket::Interface::GetSockOptCompleterBase::Reply(::fidl::DecodedMessage<GetSockOptResponse> params) {
+ BaseSocket::SetTransactionHeaderFor::GetSockOptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void BaseSocket::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<BaseSocket::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<BaseSocket::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<BaseSocket::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<BaseSocket::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<BaseSocket::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<BaseSocket::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<BaseSocket::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<BaseSocket::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<BaseSocket::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<BaseSocket::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<BaseSocket::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<BaseSocket::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<BaseSocket::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<BaseSocket::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<BaseSocket::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<BaseSocket::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::BindRequest(const ::fidl::DecodedMessage<BaseSocket::BindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::BindResponse(const ::fidl::DecodedMessage<BaseSocket::BindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::ConnectRequest(const ::fidl::DecodedMessage<BaseSocket::ConnectRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::ConnectResponse(const ::fidl::DecodedMessage<BaseSocket::ConnectResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::GetSockNameRequest(const ::fidl::DecodedMessage<BaseSocket::GetSockNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_GetSockName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::GetSockNameResponse(const ::fidl::DecodedMessage<BaseSocket::GetSockNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_GetSockName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::GetPeerNameRequest(const ::fidl::DecodedMessage<BaseSocket::GetPeerNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_GetPeerName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::GetPeerNameResponse(const ::fidl::DecodedMessage<BaseSocket::GetPeerNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_GetPeerName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::SetSockOptRequest(const ::fidl::DecodedMessage<BaseSocket::SetSockOptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_SetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::SetSockOptResponse(const ::fidl::DecodedMessage<BaseSocket::SetSockOptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_SetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BaseSocket::SetTransactionHeaderFor::GetSockOptRequest(const ::fidl::DecodedMessage<BaseSocket::GetSockOptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_GetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BaseSocket::SetTransactionHeaderFor::GetSockOptResponse(const ::fidl::DecodedMessage<BaseSocket::GetSockOptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBaseSocket_GetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Bind_Ordinal = 0x11ebbc3c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Bind_GenOrdinal = 0xf8457e6b05e15bclu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketBindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Connect_Ordinal = 0x62cb94300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Connect_GenOrdinal = 0x17abeee0b9843bb1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketConnectResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_GetSockName_Ordinal = 0x7c14255c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_GetSockName_GenOrdinal = 0x41a618ef19a91f9dlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetSockNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetSockNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_GetPeerName_Ordinal = 0x4beee9b000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_GetPeerName_GenOrdinal = 0x4009d08a4beb5e95lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetPeerNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetPeerNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_SetSockOpt_Ordinal = 0x497c444100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_SetSockOpt_GenOrdinal = 0x93c6f802203e6f1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSetSockOptResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_GetSockOpt_Ordinal = 0x3b2b8b3d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_GetSockOpt_GenOrdinal = 0x6dfaf70f0ed40544lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetSockOptResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Listen_Ordinal = 0x29346af600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Listen_GenOrdinal = 0x3d0a65ced3d10108lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketListenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketListenResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Accept_Ordinal = 0x4c59510900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kStreamSocket_Accept_GenOrdinal = 0x5ab7ad620424c163lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketAcceptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketAcceptResponseTable;
+
+} // namespace
+
+StreamSocket::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ StreamSocket::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+StreamSocket::ResultOf::Clone StreamSocket::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+StreamSocket::ResultOf::Clone StreamSocket::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+StreamSocket::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ StreamSocket::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+StreamSocket::UnownedResultOf::Clone StreamSocket::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+StreamSocket::UnownedResultOf::Clone StreamSocket::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError StreamSocket::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ StreamSocket::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+StreamSocket::ResultOf::Close_Impl<StreamSocket::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::Close StreamSocket::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+StreamSocket::ResultOf::Close StreamSocket::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+StreamSocket::UnownedResultOf::Close_Impl<StreamSocket::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::Close StreamSocket::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::Close StreamSocket::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::CloseResponse> StreamSocket::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ StreamSocket::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::Describe_Impl<StreamSocket::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::Describe StreamSocket::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+StreamSocket::ResultOf::Describe StreamSocket::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+StreamSocket::UnownedResultOf::Describe_Impl<StreamSocket::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::Describe StreamSocket::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::Describe StreamSocket::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::DescribeResponse> StreamSocket::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ StreamSocket::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::Sync_Impl<StreamSocket::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::Sync StreamSocket::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+StreamSocket::ResultOf::Sync StreamSocket::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+StreamSocket::UnownedResultOf::Sync_Impl<StreamSocket::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::Sync StreamSocket::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::Sync StreamSocket::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::SyncResponse> StreamSocket::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ StreamSocket::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::GetAttr_Impl<StreamSocket::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::GetAttr StreamSocket::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+StreamSocket::ResultOf::GetAttr StreamSocket::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+StreamSocket::UnownedResultOf::GetAttr_Impl<StreamSocket::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::GetAttr StreamSocket::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::GetAttr StreamSocket::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::GetAttrResponse> StreamSocket::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ StreamSocket::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::SetAttr_Impl<StreamSocket::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::SetAttr StreamSocket::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+StreamSocket::ResultOf::SetAttr StreamSocket::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+StreamSocket::UnownedResultOf::SetAttr_Impl<StreamSocket::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::SetAttr StreamSocket::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::SetAttr StreamSocket::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::SetAttrResponse> StreamSocket::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ StreamSocket::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::NodeGetFlags_Impl<StreamSocket::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::NodeGetFlags StreamSocket::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+StreamSocket::ResultOf::NodeGetFlags StreamSocket::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+StreamSocket::UnownedResultOf::NodeGetFlags_Impl<StreamSocket::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::NodeGetFlags StreamSocket::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::NodeGetFlags StreamSocket::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::NodeGetFlagsResponse> StreamSocket::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ StreamSocket::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::NodeSetFlags_Impl<StreamSocket::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::NodeSetFlags StreamSocket::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+StreamSocket::ResultOf::NodeSetFlags StreamSocket::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+StreamSocket::UnownedResultOf::NodeSetFlags_Impl<StreamSocket::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::NodeSetFlags StreamSocket::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::NodeSetFlags StreamSocket::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::NodeSetFlagsResponse> StreamSocket::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ StreamSocket::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::Bind_Impl<StreamSocket::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ BindRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ StreamSocket::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::Bind StreamSocket::SyncClient::Bind(::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+StreamSocket::ResultOf::Bind StreamSocket::Call::Bind(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Bind(std::move(_client_end), std::move(addr));
+}
+
+template <>
+StreamSocket::UnownedResultOf::Bind_Impl<StreamSocket::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BindRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BindResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ BindRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ StreamSocket::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::Bind StreamSocket::SyncClient::Bind(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::Bind StreamSocket::Call::Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::BindResponse> StreamSocket::InPlace::Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer) {
+ StreamSocket::SetTransactionHeaderFor::BindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::BindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BindRequest, BindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::BindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::Connect_Impl<StreamSocket::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ConnectRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ StreamSocket::InPlace::Connect(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::Connect StreamSocket::SyncClient::Connect(::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+StreamSocket::ResultOf::Connect StreamSocket::Call::Connect(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Connect(std::move(_client_end), std::move(addr));
+}
+
+template <>
+StreamSocket::UnownedResultOf::Connect_Impl<StreamSocket::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConnectRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConnectResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ ConnectRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ StreamSocket::InPlace::Connect(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::Connect StreamSocket::SyncClient::Connect(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::Connect StreamSocket::Call::Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::ConnectResponse> StreamSocket::InPlace::Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params, ::fidl::BytePart response_buffer) {
+ StreamSocket::SetTransactionHeaderFor::ConnectRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::ConnectResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConnectRequest, ConnectResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::ConnectResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::GetSockName_Impl<StreamSocket::GetSockNameResponse>::GetSockName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSockNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSockNameRequest));
+ ::fidl::DecodedMessage<GetSockNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::GetSockName(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::GetSockName StreamSocket::SyncClient::GetSockName() {
+ return ResultOf::GetSockName(::zx::unowned_channel(this->channel_));
+}
+
+StreamSocket::ResultOf::GetSockName StreamSocket::Call::GetSockName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetSockName(std::move(_client_end));
+}
+
+template <>
+StreamSocket::UnownedResultOf::GetSockName_Impl<StreamSocket::GetSockNameResponse>::GetSockName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetSockNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetSockNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetSockNameRequest));
+ ::fidl::DecodedMessage<GetSockNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::GetSockName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::GetSockName StreamSocket::SyncClient::GetSockName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::GetSockName StreamSocket::Call::GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::GetSockNameResponse> StreamSocket::InPlace::GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetSockNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetSockNameRequest> params(std::move(_request_buffer));
+ StreamSocket::SetTransactionHeaderFor::GetSockNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::GetSockNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSockNameRequest, GetSockNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::GetSockNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::GetPeerName_Impl<StreamSocket::GetPeerNameResponse>::GetPeerName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPeerNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPeerNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPeerNameRequest));
+ ::fidl::DecodedMessage<GetPeerNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::GetPeerName(std::move(_client_end), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::GetPeerName StreamSocket::SyncClient::GetPeerName() {
+ return ResultOf::GetPeerName(::zx::unowned_channel(this->channel_));
+}
+
+StreamSocket::ResultOf::GetPeerName StreamSocket::Call::GetPeerName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetPeerName(std::move(_client_end));
+}
+
+template <>
+StreamSocket::UnownedResultOf::GetPeerName_Impl<StreamSocket::GetPeerNameResponse>::GetPeerName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPeerNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPeerNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPeerNameRequest));
+ ::fidl::DecodedMessage<GetPeerNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::GetPeerName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::GetPeerName StreamSocket::SyncClient::GetPeerName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPeerName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::GetPeerName StreamSocket::Call::GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPeerName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::GetPeerNameResponse> StreamSocket::InPlace::GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPeerNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPeerNameRequest> params(std::move(_request_buffer));
+ StreamSocket::SetTransactionHeaderFor::GetPeerNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::GetPeerNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPeerNameRequest, GetPeerNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::GetPeerNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::SetSockOpt_Impl<StreamSocket::SetSockOptResponse>::SetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSockOptRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetSockOptRequest _request = {};
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetSockOptRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ StreamSocket::InPlace::SetSockOpt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::SetSockOpt StreamSocket::SyncClient::SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ return ResultOf::SetSockOpt(::zx::unowned_channel(this->channel_), std::move(level), std::move(optname), std::move(optval));
+}
+
+StreamSocket::ResultOf::SetSockOpt StreamSocket::Call::SetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ return ResultOf::SetSockOpt(std::move(_client_end), std::move(level), std::move(optname), std::move(optval));
+}
+
+template <>
+StreamSocket::UnownedResultOf::SetSockOpt_Impl<StreamSocket::SetSockOptResponse>::SetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetSockOptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetSockOptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetSockOptRequest _request = {};
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetSockOptRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ StreamSocket::InPlace::SetSockOpt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::SetSockOpt StreamSocket::SyncClient::SetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSockOpt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(level), std::move(optname), std::move(optval), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::SetSockOpt StreamSocket::Call::SetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSockOpt(std::move(_client_end), std::move(_request_buffer), std::move(level), std::move(optname), std::move(optval), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::SetSockOptResponse> StreamSocket::InPlace::SetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSockOptRequest> params, ::fidl::BytePart response_buffer) {
+ StreamSocket::SetTransactionHeaderFor::SetSockOptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::SetSockOptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetSockOptRequest, SetSockOptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::SetSockOptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::GetSockOpt_Impl<StreamSocket::GetSockOptResponse>::GetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockOptRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSockOptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSockOptRequest*>(_write_bytes);
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSockOptRequest));
+ ::fidl::DecodedMessage<GetSockOptRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::GetSockOpt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::GetSockOpt StreamSocket::SyncClient::GetSockOpt(int16_t level, int16_t optname) {
+ return ResultOf::GetSockOpt(::zx::unowned_channel(this->channel_), std::move(level), std::move(optname));
+}
+
+StreamSocket::ResultOf::GetSockOpt StreamSocket::Call::GetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname) {
+ return ResultOf::GetSockOpt(std::move(_client_end), std::move(level), std::move(optname));
+}
+
+template <>
+StreamSocket::UnownedResultOf::GetSockOpt_Impl<StreamSocket::GetSockOptResponse>::GetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetSockOptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetSockOptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetSockOptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSockOptRequest*>(_request_buffer.data());
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request_buffer.set_actual(sizeof(GetSockOptRequest));
+ ::fidl::DecodedMessage<GetSockOptRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::GetSockOpt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::GetSockOpt StreamSocket::SyncClient::GetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockOpt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(level), std::move(optname), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::GetSockOpt StreamSocket::Call::GetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockOpt(std::move(_client_end), std::move(_request_buffer), std::move(level), std::move(optname), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::GetSockOptResponse> StreamSocket::InPlace::GetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSockOptRequest> params, ::fidl::BytePart response_buffer) {
+ StreamSocket::SetTransactionHeaderFor::GetSockOptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::GetSockOptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSockOptRequest, GetSockOptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::GetSockOptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::Listen_Impl<StreamSocket::ListenResponse>::Listen_Impl(::zx::unowned_channel _client_end, int16_t backlog) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ListenRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ListenRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ListenRequest*>(_write_bytes);
+ _request.backlog = std::move(backlog);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ListenRequest));
+ ::fidl::DecodedMessage<ListenRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::Listen(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::Listen StreamSocket::SyncClient::Listen(int16_t backlog) {
+ return ResultOf::Listen(::zx::unowned_channel(this->channel_), std::move(backlog));
+}
+
+StreamSocket::ResultOf::Listen StreamSocket::Call::Listen(::zx::unowned_channel _client_end, int16_t backlog) {
+ return ResultOf::Listen(std::move(_client_end), std::move(backlog));
+}
+
+template <>
+StreamSocket::UnownedResultOf::Listen_Impl<StreamSocket::ListenResponse>::Listen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ListenRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ListenResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ListenRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ListenRequest*>(_request_buffer.data());
+ _request.backlog = std::move(backlog);
+ _request_buffer.set_actual(sizeof(ListenRequest));
+ ::fidl::DecodedMessage<ListenRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::Listen(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::Listen StreamSocket::SyncClient::Listen(::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Listen(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(backlog), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::Listen StreamSocket::Call::Listen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Listen(std::move(_client_end), std::move(_request_buffer), std::move(backlog), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::ListenResponse> StreamSocket::InPlace::Listen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ListenRequest> params, ::fidl::BytePart response_buffer) {
+ StreamSocket::SetTransactionHeaderFor::ListenRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::ListenResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ListenRequest, ListenResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::ListenResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+StreamSocket::ResultOf::Accept_Impl<StreamSocket::AcceptResponse>::Accept_Impl(::zx::unowned_channel _client_end, int16_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AcceptRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AcceptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AcceptRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AcceptRequest));
+ ::fidl::DecodedMessage<AcceptRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ StreamSocket::InPlace::Accept(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+StreamSocket::ResultOf::Accept StreamSocket::SyncClient::Accept(int16_t flags) {
+ return ResultOf::Accept(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+StreamSocket::ResultOf::Accept StreamSocket::Call::Accept(::zx::unowned_channel _client_end, int16_t flags) {
+ return ResultOf::Accept(std::move(_client_end), std::move(flags));
+}
+
+template <>
+StreamSocket::UnownedResultOf::Accept_Impl<StreamSocket::AcceptResponse>::Accept_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AcceptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AcceptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AcceptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AcceptRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(AcceptRequest));
+ ::fidl::DecodedMessage<AcceptRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ StreamSocket::InPlace::Accept(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+StreamSocket::UnownedResultOf::Accept StreamSocket::SyncClient::Accept(::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Accept(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+StreamSocket::UnownedResultOf::Accept StreamSocket::Call::Accept(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Accept(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<StreamSocket::AcceptResponse> StreamSocket::InPlace::Accept(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AcceptRequest> params, ::fidl::BytePart response_buffer) {
+ StreamSocket::SetTransactionHeaderFor::AcceptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::AcceptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AcceptRequest, AcceptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<StreamSocket::AcceptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t StreamSocket::SyncClient::HandleEvents(StreamSocket::EventHandlers handlers) {
+ return StreamSocket::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t StreamSocket::Call::HandleEvents(::zx::unowned_channel client_end, StreamSocket::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kStreamSocket_OnOpen_Ordinal:
+ case kStreamSocket_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool StreamSocket::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kStreamSocket_Clone_Ordinal:
+ case kStreamSocket_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_Close_Ordinal:
+ case kStreamSocket_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_Describe_Ordinal:
+ case kStreamSocket_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_Sync_Ordinal:
+ case kStreamSocket_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_GetAttr_Ordinal:
+ case kStreamSocket_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_SetAttr_Ordinal:
+ case kStreamSocket_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_NodeGetFlags_Ordinal:
+ case kStreamSocket_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_NodeSetFlags_Ordinal:
+ case kStreamSocket_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_Bind_Ordinal:
+ case kStreamSocket_Bind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Bind(std::move(message->addr),
+ Interface::BindCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_Connect_Ordinal:
+ case kStreamSocket_Connect_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConnectRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Connect(std::move(message->addr),
+ Interface::ConnectCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_GetSockName_Ordinal:
+ case kStreamSocket_GetSockName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSockNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetSockName(
+ Interface::GetSockNameCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_GetPeerName_Ordinal:
+ case kStreamSocket_GetPeerName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPeerNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetPeerName(
+ Interface::GetPeerNameCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_SetSockOpt_Ordinal:
+ case kStreamSocket_SetSockOpt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetSockOptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetSockOpt(std::move(message->level), std::move(message->optname), std::move(message->optval),
+ Interface::SetSockOptCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_GetSockOpt_Ordinal:
+ case kStreamSocket_GetSockOpt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSockOptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetSockOpt(std::move(message->level), std::move(message->optname),
+ Interface::GetSockOptCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_Listen_Ordinal:
+ case kStreamSocket_Listen_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ListenRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Listen(std::move(message->backlog),
+ Interface::ListenCompleter::Sync(txn));
+ return true;
+ }
+ case kStreamSocket_Accept_Ordinal:
+ case kStreamSocket_Accept_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AcceptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Accept(std::move(message->flags),
+ Interface::AcceptCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool StreamSocket::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void StreamSocket::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ StreamSocket::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void StreamSocket::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ StreamSocket::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void StreamSocket::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamSocket::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void StreamSocket::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t StreamSocket::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t StreamSocket::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t StreamSocket::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void StreamSocket::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ StreamSocket::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void StreamSocket::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ StreamSocket::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void StreamSocket::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ StreamSocket::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void StreamSocket::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ StreamSocket::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void StreamSocket::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ StreamSocket::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void StreamSocket::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ StreamSocket::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void StreamSocket::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ StreamSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void StreamSocket::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ StreamSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void StreamSocket::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ StreamSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void StreamSocket::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ StreamSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void StreamSocket::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::BindCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ BindResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::BindCompleterBase::ReplySuccess() {
+ BaseSocket_Bind_Response response;
+
+ Reply(BaseSocket_Bind_Result::WithResponse(&response));
+}
+void StreamSocket::Interface::BindCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_Bind_Result::WithErr(&error));
+}
+
+void StreamSocket::Interface::BindCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result) {
+ if (_buffer.capacity() < BindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ BindResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::BindCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_Bind_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_Bind_Result::WithResponse(&response));
+}
+
+void StreamSocket::Interface::BindCompleterBase::Reply(::fidl::DecodedMessage<BindResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::BindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::ConnectCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ConnectResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::ConnectCompleterBase::ReplySuccess() {
+ BaseSocket_Connect_Response response;
+
+ Reply(BaseSocket_Connect_Result::WithResponse(&response));
+}
+void StreamSocket::Interface::ConnectCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_Connect_Result::WithErr(&error));
+}
+
+void StreamSocket::Interface::ConnectCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result) {
+ if (_buffer.capacity() < ConnectResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ConnectResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::ConnectCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_Connect_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_Connect_Result::WithResponse(&response));
+}
+
+void StreamSocket::Interface::ConnectCompleterBase::Reply(::fidl::DecodedMessage<ConnectResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::ConnectResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::GetSockNameCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetSockNameResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::GetSockNameResponse(
+ ::fidl::DecodedMessage<GetSockNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockNameResponse::PrimarySize,
+ GetSockNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::GetSockNameCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetSockName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(BaseSocket_GetSockName_Result::WithResponse(&response));
+}
+void StreamSocket::Interface::GetSockNameCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetSockName_Result::WithErr(&error));
+}
+
+void StreamSocket::Interface::GetSockNameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result) {
+ if (_buffer.capacity() < GetSockNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSockNameResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::GetSockNameResponse(
+ ::fidl::DecodedMessage<GetSockNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockNameResponse::PrimarySize,
+ GetSockNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::GetSockNameCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetSockName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(std::move(_buffer), BaseSocket_GetSockName_Result::WithResponse(&response));
+}
+
+void StreamSocket::Interface::GetSockNameCompleterBase::Reply(::fidl::DecodedMessage<GetSockNameResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::GetSockNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::GetPeerNameCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPeerNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetPeerNameResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::GetPeerNameResponse(
+ ::fidl::DecodedMessage<GetPeerNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPeerNameResponse::PrimarySize,
+ GetPeerNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::GetPeerNameCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetPeerName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(BaseSocket_GetPeerName_Result::WithResponse(&response));
+}
+void StreamSocket::Interface::GetPeerNameCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetPeerName_Result::WithErr(&error));
+}
+
+void StreamSocket::Interface::GetPeerNameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result) {
+ if (_buffer.capacity() < GetPeerNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPeerNameResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::GetPeerNameResponse(
+ ::fidl::DecodedMessage<GetPeerNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPeerNameResponse::PrimarySize,
+ GetPeerNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::GetPeerNameCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetPeerName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(std::move(_buffer), BaseSocket_GetPeerName_Result::WithResponse(&response));
+}
+
+void StreamSocket::Interface::GetPeerNameCompleterBase::Reply(::fidl::DecodedMessage<GetPeerNameResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::GetPeerNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::SetSockOptCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSockOptResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SetSockOptResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::SetSockOptResponse(
+ ::fidl::DecodedMessage<SetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSockOptResponse::PrimarySize,
+ SetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::SetSockOptCompleterBase::ReplySuccess() {
+ BaseSocket_SetSockOpt_Response response;
+
+ Reply(BaseSocket_SetSockOpt_Result::WithResponse(&response));
+}
+void StreamSocket::Interface::SetSockOptCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_SetSockOpt_Result::WithErr(&error));
+}
+
+void StreamSocket::Interface::SetSockOptCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result) {
+ if (_buffer.capacity() < SetSockOptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SetSockOptResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::SetSockOptResponse(
+ ::fidl::DecodedMessage<SetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSockOptResponse::PrimarySize,
+ SetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::SetSockOptCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_SetSockOpt_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_SetSockOpt_Result::WithResponse(&response));
+}
+
+void StreamSocket::Interface::SetSockOptCompleterBase::Reply(::fidl::DecodedMessage<SetSockOptResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::SetSockOptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::GetSockOptCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockOptResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetSockOptResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::GetSockOptResponse(
+ ::fidl::DecodedMessage<GetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockOptResponse::PrimarySize,
+ GetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::GetSockOptCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> optval) {
+ BaseSocket_GetSockOpt_Response response;
+ response.optval = std::move(optval);
+
+ Reply(BaseSocket_GetSockOpt_Result::WithResponse(&response));
+}
+void StreamSocket::Interface::GetSockOptCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetSockOpt_Result::WithErr(&error));
+}
+
+void StreamSocket::Interface::GetSockOptCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result) {
+ if (_buffer.capacity() < GetSockOptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSockOptResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::GetSockOptResponse(
+ ::fidl::DecodedMessage<GetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockOptResponse::PrimarySize,
+ GetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::GetSockOptCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> optval) {
+ BaseSocket_GetSockOpt_Response response;
+ response.optval = std::move(optval);
+
+ Reply(std::move(_buffer), BaseSocket_GetSockOpt_Result::WithResponse(&response));
+}
+
+void StreamSocket::Interface::GetSockOptCompleterBase::Reply(::fidl::DecodedMessage<GetSockOptResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::GetSockOptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::ListenCompleterBase::Reply(::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ListenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ListenResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::ListenResponse(
+ ::fidl::DecodedMessage<ListenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ListenResponse::PrimarySize,
+ ListenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::ListenCompleterBase::ReplySuccess() {
+ StreamSocket_Listen_Response response;
+
+ Reply(StreamSocket_Listen_Result::WithResponse(&response));
+}
+void StreamSocket::Interface::ListenCompleterBase::ReplyError(int32_t error) {
+ Reply(StreamSocket_Listen_Result::WithErr(&error));
+}
+
+void StreamSocket::Interface::ListenCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Result result) {
+ if (_buffer.capacity() < ListenResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ListenResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::ListenResponse(
+ ::fidl::DecodedMessage<ListenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ListenResponse::PrimarySize,
+ ListenResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::ListenCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ StreamSocket_Listen_Response response;
+
+ Reply(std::move(_buffer), StreamSocket_Listen_Result::WithResponse(&response));
+}
+
+void StreamSocket::Interface::ListenCompleterBase::Reply(::fidl::DecodedMessage<ListenResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::ListenResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void StreamSocket::Interface::AcceptCompleterBase::Reply(::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AcceptResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ AcceptResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::AcceptResponse(
+ ::fidl::DecodedMessage<AcceptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AcceptResponse::PrimarySize,
+ AcceptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::AcceptCompleterBase::ReplySuccess(::zx::channel s) {
+ StreamSocket_Accept_Response response;
+ response.s = std::move(s);
+
+ Reply(StreamSocket_Accept_Result::WithResponse(&response));
+}
+void StreamSocket::Interface::AcceptCompleterBase::ReplyError(int32_t error) {
+ Reply(StreamSocket_Accept_Result::WithErr(&error));
+}
+
+void StreamSocket::Interface::AcceptCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Result result) {
+ if (_buffer.capacity() < AcceptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ AcceptResponse _response = {};
+ StreamSocket::SetTransactionHeaderFor::AcceptResponse(
+ ::fidl::DecodedMessage<AcceptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AcceptResponse::PrimarySize,
+ AcceptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void StreamSocket::Interface::AcceptCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::zx::channel s) {
+ StreamSocket_Accept_Response response;
+ response.s = std::move(s);
+
+ Reply(std::move(_buffer), StreamSocket_Accept_Result::WithResponse(&response));
+}
+
+void StreamSocket::Interface::AcceptCompleterBase::Reply(::fidl::DecodedMessage<AcceptResponse> params) {
+ StreamSocket::SetTransactionHeaderFor::AcceptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void StreamSocket::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<StreamSocket::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<StreamSocket::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<StreamSocket::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<StreamSocket::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<StreamSocket::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<StreamSocket::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<StreamSocket::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<StreamSocket::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<StreamSocket::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<StreamSocket::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<StreamSocket::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<StreamSocket::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<StreamSocket::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<StreamSocket::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<StreamSocket::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<StreamSocket::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::BindRequest(const ::fidl::DecodedMessage<StreamSocket::BindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::BindResponse(const ::fidl::DecodedMessage<StreamSocket::BindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::ConnectRequest(const ::fidl::DecodedMessage<StreamSocket::ConnectRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::ConnectResponse(const ::fidl::DecodedMessage<StreamSocket::ConnectResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::GetSockNameRequest(const ::fidl::DecodedMessage<StreamSocket::GetSockNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_GetSockName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::GetSockNameResponse(const ::fidl::DecodedMessage<StreamSocket::GetSockNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_GetSockName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::GetPeerNameRequest(const ::fidl::DecodedMessage<StreamSocket::GetPeerNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_GetPeerName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::GetPeerNameResponse(const ::fidl::DecodedMessage<StreamSocket::GetPeerNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_GetPeerName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::SetSockOptRequest(const ::fidl::DecodedMessage<StreamSocket::SetSockOptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_SetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::SetSockOptResponse(const ::fidl::DecodedMessage<StreamSocket::SetSockOptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_SetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::GetSockOptRequest(const ::fidl::DecodedMessage<StreamSocket::GetSockOptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_GetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::GetSockOptResponse(const ::fidl::DecodedMessage<StreamSocket::GetSockOptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_GetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::ListenRequest(const ::fidl::DecodedMessage<StreamSocket::ListenRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Listen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::ListenResponse(const ::fidl::DecodedMessage<StreamSocket::ListenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Listen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void StreamSocket::SetTransactionHeaderFor::AcceptRequest(const ::fidl::DecodedMessage<StreamSocket::AcceptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Accept_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void StreamSocket::SetTransactionHeaderFor::AcceptResponse(const ::fidl::DecodedMessage<StreamSocket::AcceptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kStreamSocket_Accept_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Clone_Ordinal = 0x17fe6a4c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Clone_GenOrdinal = 0x5a61678f293ce16flu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketCloneResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Close_Ordinal = 0x52b9568700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Close_GenOrdinal = 0x5309c5bd1c33dc44lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketCloseResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Describe_Ordinal = 0x1f62df5e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Describe_GenOrdinal = 0xffcec215078dea0lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketDescribeResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_OnOpen_Ordinal = 0x4700a7bd00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_OnOpen_GenOrdinal = 0x7fc7bbb1dbfd1972lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketOnOpenEventTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Sync_Ordinal = 0x62423faa00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Sync_GenOrdinal = 0x189d88326c18b519lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_GetAttr_Ordinal = 0x4585e7c800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_GetAttr_GenOrdinal = 0x78985e216314dafdlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_SetAttr_Ordinal = 0xbd5559a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_SetAttr_GenOrdinal = 0x4186c0f40d938f46lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSetAttrResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_NodeGetFlags_Ordinal = 0x3c24c22300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_NodeGetFlags_GenOrdinal = 0x5b88fffb8eda3aa1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketNodeGetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_NodeSetFlags_Ordinal = 0x46940c1600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_NodeSetFlags_GenOrdinal = 0x5295b76c71fde733lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketNodeSetFlagsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Bind_Ordinal = 0x11ebbc3c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Bind_GenOrdinal = 0xf8457e6b05e15bclu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketBindResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Connect_Ordinal = 0x62cb94300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Connect_GenOrdinal = 0x17abeee0b9843bb1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketConnectResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_GetSockName_Ordinal = 0x7c14255c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_GetSockName_GenOrdinal = 0x41a618ef19a91f9dlu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetSockNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetSockNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_GetPeerName_Ordinal = 0x4beee9b000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_GetPeerName_GenOrdinal = 0x4009d08a4beb5e95lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetPeerNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetPeerNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_SetSockOpt_Ordinal = 0x497c444100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_SetSockOpt_GenOrdinal = 0x93c6f802203e6f1lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSetSockOptResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_GetSockOpt_Ordinal = 0x3b2b8b3d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_GetSockOpt_GenOrdinal = 0x6dfaf70f0ed40544lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetSockOptResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Shutdown_Ordinal = 0x6d3a731c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_Shutdown_GenOrdinal = 0x3c6058976bced940lu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketShutdownRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketShutdownResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_RecvMsg_Ordinal = 0x50d7e5d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_RecvMsg_GenOrdinal = 0x715341bb02f02b7alu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketRecvMsgRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketRecvMsgResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_SendMsg_Ordinal = 0x3e2187f300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDatagramSocket_SendMsg_GenOrdinal = 0x359b626d62a7f17blu;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSendMsgRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSendMsgResponseTable;
+
+} // namespace
+
+DatagramSocket::ResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DatagramSocket::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DatagramSocket::ResultOf::Clone DatagramSocket::SyncClient::Clone(uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(flags), std::move(object));
+}
+
+DatagramSocket::ResultOf::Clone DatagramSocket::Call::Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object) {
+ return ResultOf::Clone(std::move(_client_end), std::move(flags), std::move(object));
+}
+
+
+DatagramSocket::UnownedResultOf::Clone_Impl::Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ if (_request_buffer.capacity() < CloneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloneRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.object = std::move(object);
+ _request_buffer.set_actual(sizeof(CloneRequest));
+ ::fidl::DecodedMessage<CloneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DatagramSocket::InPlace::Clone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DatagramSocket::UnownedResultOf::Clone DatagramSocket::SyncClient::Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+DatagramSocket::UnownedResultOf::Clone DatagramSocket::Call::Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object) {
+ return UnownedResultOf::Clone(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(object));
+}
+
+::fidl::internal::StatusAndError DatagramSocket::InPlace::Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params) {
+ DatagramSocket::SetTransactionHeaderFor::CloneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+DatagramSocket::ResultOf::Close_Impl<DatagramSocket::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::Close DatagramSocket::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+DatagramSocket::ResultOf::Close DatagramSocket::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::Close_Impl<DatagramSocket::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::Close DatagramSocket::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::Close DatagramSocket::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::CloseResponse> DatagramSocket::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ DatagramSocket::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::Describe_Impl<DatagramSocket::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DescribeRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::Describe(std::move(_client_end), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::Describe DatagramSocket::SyncClient::Describe() {
+ return ResultOf::Describe(::zx::unowned_channel(this->channel_));
+}
+
+DatagramSocket::ResultOf::Describe DatagramSocket::Call::Describe(::zx::unowned_channel _client_end) {
+ return ResultOf::Describe(std::move(_client_end));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::Describe_Impl<DatagramSocket::DescribeResponse>::Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(DescribeRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, DescribeRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(DescribeRequest));
+ ::fidl::DecodedMessage<DescribeRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::Describe(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::Describe DatagramSocket::SyncClient::Describe(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::Describe DatagramSocket::Call::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Describe(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::DescribeResponse> DatagramSocket::InPlace::Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(DescribeRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<DescribeRequest> params(std::move(_request_buffer));
+ DatagramSocket::SetTransactionHeaderFor::DescribeRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::DescribeResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DescribeRequest, DescribeResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::DescribeResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::Sync_Impl<DatagramSocket::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::Sync DatagramSocket::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+DatagramSocket::ResultOf::Sync DatagramSocket::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::Sync_Impl<DatagramSocket::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(SyncRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, SyncRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::Sync(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::Sync DatagramSocket::SyncClient::Sync(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::Sync DatagramSocket::Call::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Sync(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::SyncResponse> DatagramSocket::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ DatagramSocket::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::GetAttr_Impl<DatagramSocket::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetAttrRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::GetAttr(std::move(_client_end), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::GetAttr DatagramSocket::SyncClient::GetAttr() {
+ return ResultOf::GetAttr(::zx::unowned_channel(this->channel_));
+}
+
+DatagramSocket::ResultOf::GetAttr DatagramSocket::Call::GetAttr(::zx::unowned_channel _client_end) {
+ return ResultOf::GetAttr(std::move(_client_end));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::GetAttr_Impl<DatagramSocket::GetAttrResponse>::GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetAttrRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetAttrRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetAttrRequest));
+ ::fidl::DecodedMessage<GetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::GetAttr(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::GetAttr DatagramSocket::SyncClient::GetAttr(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::GetAttr DatagramSocket::Call::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetAttr(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::GetAttrResponse> DatagramSocket::InPlace::GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetAttrRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetAttrRequest> params(std::move(_request_buffer));
+ DatagramSocket::SetTransactionHeaderFor::GetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::GetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetAttrRequest, GetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::GetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::SetAttr_Impl<DatagramSocket::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::SetAttr DatagramSocket::SyncClient::SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(flags), std::move(attributes));
+}
+
+DatagramSocket::ResultOf::SetAttr DatagramSocket::Call::SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ return ResultOf::SetAttr(std::move(_client_end), std::move(flags), std::move(attributes));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::SetAttr_Impl<DatagramSocket::SetAttrResponse>::SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetAttrRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetAttrResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetAttrRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetAttrRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request.attributes = std::move(attributes);
+ _request_buffer.set_actual(sizeof(SetAttrRequest));
+ ::fidl::DecodedMessage<SetAttrRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::SetAttr(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::SetAttr DatagramSocket::SyncClient::SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::SetAttr DatagramSocket::Call::SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetAttr(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(attributes), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::SetAttrResponse> DatagramSocket::InPlace::SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::SetAttrRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::SetAttrResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetAttrRequest, SetAttrResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::SetAttrResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::NodeGetFlags_Impl<DatagramSocket::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeGetFlagsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::NodeGetFlags(std::move(_client_end), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::NodeGetFlags DatagramSocket::SyncClient::NodeGetFlags() {
+ return ResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_));
+}
+
+DatagramSocket::ResultOf::NodeGetFlags DatagramSocket::Call::NodeGetFlags(::zx::unowned_channel _client_end) {
+ return ResultOf::NodeGetFlags(std::move(_client_end));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::NodeGetFlags_Impl<DatagramSocket::NodeGetFlagsResponse>::NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(NodeGetFlagsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, NodeGetFlagsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(NodeGetFlagsRequest));
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::NodeGetFlags(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::NodeGetFlags DatagramSocket::SyncClient::NodeGetFlags(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::NodeGetFlags DatagramSocket::Call::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeGetFlags(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::NodeGetFlagsResponse> DatagramSocket::InPlace::NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(NodeGetFlagsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NodeGetFlagsRequest> params(std::move(_request_buffer));
+ DatagramSocket::SetTransactionHeaderFor::NodeGetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::NodeGetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeGetFlagsRequest, NodeGetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::NodeGetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::NodeSetFlags_Impl<DatagramSocket::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_write_bytes);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::NodeSetFlags DatagramSocket::SyncClient::NodeSetFlags(uint32_t flags) {
+ return ResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(flags));
+}
+
+DatagramSocket::ResultOf::NodeSetFlags DatagramSocket::Call::NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags) {
+ return ResultOf::NodeSetFlags(std::move(_client_end), std::move(flags));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::NodeSetFlags_Impl<DatagramSocket::NodeSetFlagsResponse>::NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < NodeSetFlagsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<NodeSetFlagsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, NodeSetFlagsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<NodeSetFlagsRequest*>(_request_buffer.data());
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(NodeSetFlagsRequest));
+ ::fidl::DecodedMessage<NodeSetFlagsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::NodeSetFlags(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::NodeSetFlags DatagramSocket::SyncClient::NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::NodeSetFlags DatagramSocket::Call::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::NodeSetFlags(std::move(_client_end), std::move(_request_buffer), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::NodeSetFlagsResponse> DatagramSocket::InPlace::NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::NodeSetFlagsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::NodeSetFlagsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<NodeSetFlagsRequest, NodeSetFlagsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::NodeSetFlagsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::Bind_Impl<DatagramSocket::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ BindRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DatagramSocket::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::Bind DatagramSocket::SyncClient::Bind(::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+DatagramSocket::ResultOf::Bind DatagramSocket::Call::Bind(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Bind(std::move(_client_end), std::move(addr));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::Bind_Impl<DatagramSocket::BindResponse>::Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < BindRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<BindResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ BindRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<BindRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DatagramSocket::InPlace::Bind(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::Bind DatagramSocket::SyncClient::Bind(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::Bind DatagramSocket::Call::Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Bind(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::BindResponse> DatagramSocket::InPlace::Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::BindRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::BindResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<BindRequest, BindResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::BindResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::Connect_Impl<DatagramSocket::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ConnectRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DatagramSocket::InPlace::Connect(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::Connect DatagramSocket::SyncClient::Connect(::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(addr));
+}
+
+DatagramSocket::ResultOf::Connect DatagramSocket::Call::Connect(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr) {
+ return ResultOf::Connect(std::move(_client_end), std::move(addr));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::Connect_Impl<DatagramSocket::ConnectResponse>::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConnectRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConnectResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ ConnectRequest _request = {};
+ _request.addr = std::move(addr);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DatagramSocket::InPlace::Connect(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::Connect DatagramSocket::SyncClient::Connect(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::Connect DatagramSocket::Call::Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Connect(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::ConnectResponse> DatagramSocket::InPlace::Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::ConnectRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::ConnectResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConnectRequest, ConnectResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::ConnectResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::GetSockName_Impl<DatagramSocket::GetSockNameResponse>::GetSockName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSockNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSockNameRequest));
+ ::fidl::DecodedMessage<GetSockNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::GetSockName(std::move(_client_end), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::GetSockName DatagramSocket::SyncClient::GetSockName() {
+ return ResultOf::GetSockName(::zx::unowned_channel(this->channel_));
+}
+
+DatagramSocket::ResultOf::GetSockName DatagramSocket::Call::GetSockName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetSockName(std::move(_client_end));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::GetSockName_Impl<DatagramSocket::GetSockNameResponse>::GetSockName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetSockNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetSockNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetSockNameRequest));
+ ::fidl::DecodedMessage<GetSockNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::GetSockName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::GetSockName DatagramSocket::SyncClient::GetSockName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::GetSockName DatagramSocket::Call::GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::GetSockNameResponse> DatagramSocket::InPlace::GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetSockNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetSockNameRequest> params(std::move(_request_buffer));
+ DatagramSocket::SetTransactionHeaderFor::GetSockNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::GetSockNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSockNameRequest, GetSockNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::GetSockNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::GetPeerName_Impl<DatagramSocket::GetPeerNameResponse>::GetPeerName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPeerNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPeerNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPeerNameRequest));
+ ::fidl::DecodedMessage<GetPeerNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::GetPeerName(std::move(_client_end), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::GetPeerName DatagramSocket::SyncClient::GetPeerName() {
+ return ResultOf::GetPeerName(::zx::unowned_channel(this->channel_));
+}
+
+DatagramSocket::ResultOf::GetPeerName DatagramSocket::Call::GetPeerName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetPeerName(std::move(_client_end));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::GetPeerName_Impl<DatagramSocket::GetPeerNameResponse>::GetPeerName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPeerNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPeerNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPeerNameRequest));
+ ::fidl::DecodedMessage<GetPeerNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::GetPeerName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::GetPeerName DatagramSocket::SyncClient::GetPeerName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPeerName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::GetPeerName DatagramSocket::Call::GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPeerName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::GetPeerNameResponse> DatagramSocket::InPlace::GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPeerNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPeerNameRequest> params(std::move(_request_buffer));
+ DatagramSocket::SetTransactionHeaderFor::GetPeerNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::GetPeerNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPeerNameRequest, GetPeerNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::GetPeerNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::SetSockOpt_Impl<DatagramSocket::SetSockOptResponse>::SetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSockOptRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SetSockOptRequest _request = {};
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetSockOptRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DatagramSocket::InPlace::SetSockOpt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::SetSockOpt DatagramSocket::SyncClient::SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ return ResultOf::SetSockOpt(::zx::unowned_channel(this->channel_), std::move(level), std::move(optname), std::move(optval));
+}
+
+DatagramSocket::ResultOf::SetSockOpt DatagramSocket::Call::SetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval) {
+ return ResultOf::SetSockOpt(std::move(_client_end), std::move(level), std::move(optname), std::move(optval));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::SetSockOpt_Impl<DatagramSocket::SetSockOptResponse>::SetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetSockOptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetSockOptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SetSockOptRequest _request = {};
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request.optval = std::move(optval);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SetSockOptRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DatagramSocket::InPlace::SetSockOpt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::SetSockOpt DatagramSocket::SyncClient::SetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSockOpt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(level), std::move(optname), std::move(optval), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::SetSockOpt DatagramSocket::Call::SetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetSockOpt(std::move(_client_end), std::move(_request_buffer), std::move(level), std::move(optname), std::move(optval), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::SetSockOptResponse> DatagramSocket::InPlace::SetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSockOptRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::SetSockOptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::SetSockOptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetSockOptRequest, SetSockOptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::SetSockOptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::GetSockOpt_Impl<DatagramSocket::GetSockOptResponse>::GetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockOptRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetSockOptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSockOptRequest*>(_write_bytes);
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetSockOptRequest));
+ ::fidl::DecodedMessage<GetSockOptRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::GetSockOpt(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::GetSockOpt DatagramSocket::SyncClient::GetSockOpt(int16_t level, int16_t optname) {
+ return ResultOf::GetSockOpt(::zx::unowned_channel(this->channel_), std::move(level), std::move(optname));
+}
+
+DatagramSocket::ResultOf::GetSockOpt DatagramSocket::Call::GetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname) {
+ return ResultOf::GetSockOpt(std::move(_client_end), std::move(level), std::move(optname));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::GetSockOpt_Impl<DatagramSocket::GetSockOptResponse>::GetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < GetSockOptRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<GetSockOptResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, GetSockOptRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<GetSockOptRequest*>(_request_buffer.data());
+ _request.level = std::move(level);
+ _request.optname = std::move(optname);
+ _request_buffer.set_actual(sizeof(GetSockOptRequest));
+ ::fidl::DecodedMessage<GetSockOptRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::GetSockOpt(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::GetSockOpt DatagramSocket::SyncClient::GetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockOpt(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(level), std::move(optname), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::GetSockOpt DatagramSocket::Call::GetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetSockOpt(std::move(_client_end), std::move(_request_buffer), std::move(level), std::move(optname), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::GetSockOptResponse> DatagramSocket::InPlace::GetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSockOptRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::GetSockOptRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::GetSockOptResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetSockOptRequest, GetSockOptResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::GetSockOptResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::Shutdown_Impl<DatagramSocket::ShutdownResponse>::Shutdown_Impl(::zx::unowned_channel _client_end, int16_t how) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShutdownRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ShutdownRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ShutdownRequest*>(_write_bytes);
+ _request.how = std::move(how);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShutdownRequest));
+ ::fidl::DecodedMessage<ShutdownRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::Shutdown(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::Shutdown DatagramSocket::SyncClient::Shutdown(int16_t how) {
+ return ResultOf::Shutdown(::zx::unowned_channel(this->channel_), std::move(how));
+}
+
+DatagramSocket::ResultOf::Shutdown DatagramSocket::Call::Shutdown(::zx::unowned_channel _client_end, int16_t how) {
+ return ResultOf::Shutdown(std::move(_client_end), std::move(how));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::Shutdown_Impl<DatagramSocket::ShutdownResponse>::Shutdown_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t how, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ShutdownRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ShutdownResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ShutdownRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ShutdownRequest*>(_request_buffer.data());
+ _request.how = std::move(how);
+ _request_buffer.set_actual(sizeof(ShutdownRequest));
+ ::fidl::DecodedMessage<ShutdownRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::Shutdown(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::Shutdown DatagramSocket::SyncClient::Shutdown(::fidl::BytePart _request_buffer, int16_t how, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Shutdown(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(how), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::Shutdown DatagramSocket::Call::Shutdown(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t how, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Shutdown(std::move(_client_end), std::move(_request_buffer), std::move(how), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::ShutdownResponse> DatagramSocket::InPlace::Shutdown(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ShutdownRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::ShutdownRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::ShutdownResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ShutdownRequest, ShutdownResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::ShutdownResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::RecvMsg_Impl<DatagramSocket::RecvMsgResponse>::RecvMsg_Impl(::zx::unowned_channel _client_end, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RecvMsgRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RecvMsgRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RecvMsgRequest*>(_write_bytes);
+ _request.addr_len = std::move(addr_len);
+ _request.data_len = std::move(data_len);
+ _request.control_len = std::move(control_len);
+ _request.flags = std::move(flags);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RecvMsgRequest));
+ ::fidl::DecodedMessage<RecvMsgRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DatagramSocket::InPlace::RecvMsg(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::RecvMsg DatagramSocket::SyncClient::RecvMsg(uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags) {
+ return ResultOf::RecvMsg(::zx::unowned_channel(this->channel_), std::move(addr_len), std::move(data_len), std::move(control_len), std::move(flags));
+}
+
+DatagramSocket::ResultOf::RecvMsg DatagramSocket::Call::RecvMsg(::zx::unowned_channel _client_end, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags) {
+ return ResultOf::RecvMsg(std::move(_client_end), std::move(addr_len), std::move(data_len), std::move(control_len), std::move(flags));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::RecvMsg_Impl<DatagramSocket::RecvMsgResponse>::RecvMsg_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < RecvMsgRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<RecvMsgResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, RecvMsgRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RecvMsgRequest*>(_request_buffer.data());
+ _request.addr_len = std::move(addr_len);
+ _request.data_len = std::move(data_len);
+ _request.control_len = std::move(control_len);
+ _request.flags = std::move(flags);
+ _request_buffer.set_actual(sizeof(RecvMsgRequest));
+ ::fidl::DecodedMessage<RecvMsgRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DatagramSocket::InPlace::RecvMsg(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::RecvMsg DatagramSocket::SyncClient::RecvMsg(::fidl::BytePart _request_buffer, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RecvMsg(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr_len), std::move(data_len), std::move(control_len), std::move(flags), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::RecvMsg DatagramSocket::Call::RecvMsg(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::RecvMsg(std::move(_client_end), std::move(_request_buffer), std::move(addr_len), std::move(data_len), std::move(control_len), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::RecvMsgResponse> DatagramSocket::InPlace::RecvMsg(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RecvMsgRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::RecvMsgRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::RecvMsgResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<RecvMsgRequest, RecvMsgResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::RecvMsgResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DatagramSocket::ResultOf::SendMsg_Impl<DatagramSocket::SendMsgResponse>::SendMsg_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SendMsgRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ SendMsgRequest _request = {};
+ _request.addr = std::move(addr);
+ _request.data = std::move(data);
+ _request.control = std::move(control);
+ _request.flags = std::move(flags);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SendMsgRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DatagramSocket::InPlace::SendMsg(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DatagramSocket::ResultOf::SendMsg DatagramSocket::SyncClient::SendMsg(::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags) {
+ return ResultOf::SendMsg(::zx::unowned_channel(this->channel_), std::move(addr), std::move(data), std::move(control), std::move(flags));
+}
+
+DatagramSocket::ResultOf::SendMsg DatagramSocket::Call::SendMsg(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags) {
+ return ResultOf::SendMsg(std::move(_client_end), std::move(addr), std::move(data), std::move(control), std::move(flags));
+}
+
+template <>
+DatagramSocket::UnownedResultOf::SendMsg_Impl<DatagramSocket::SendMsgResponse>::SendMsg_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SendMsgRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SendMsgResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ SendMsgRequest _request = {};
+ _request.addr = std::move(addr);
+ _request.data = std::move(data);
+ _request.control = std::move(control);
+ _request.flags = std::move(flags);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<SendMsgRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DatagramSocket::InPlace::SendMsg(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DatagramSocket::UnownedResultOf::SendMsg DatagramSocket::SyncClient::SendMsg(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SendMsg(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(addr), std::move(data), std::move(control), std::move(flags), std::move(_response_buffer));
+}
+
+DatagramSocket::UnownedResultOf::SendMsg DatagramSocket::Call::SendMsg(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SendMsg(std::move(_client_end), std::move(_request_buffer), std::move(addr), std::move(data), std::move(control), std::move(flags), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DatagramSocket::SendMsgResponse> DatagramSocket::InPlace::SendMsg(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SendMsgRequest> params, ::fidl::BytePart response_buffer) {
+ DatagramSocket::SetTransactionHeaderFor::SendMsgRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::SendMsgResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SendMsgRequest, SendMsgResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DatagramSocket::SendMsgResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+zx_status_t DatagramSocket::SyncClient::HandleEvents(DatagramSocket::EventHandlers handlers) {
+ return DatagramSocket::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t DatagramSocket::Call::HandleEvents(::zx::unowned_channel client_end, DatagramSocket::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnOpenResponse::MaxNumHandles >= x) {
+ x = OnOpenResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kDatagramSocket_OnOpen_Ordinal:
+ case kDatagramSocket_OnOpen_GenOrdinal:
+ {
+ constexpr uint32_t kTransformerDestSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kReceiving>();
+ ::fidl::internal::ByteStorage<kTransformerDestSize> transformer_dest_storage(::fidl::internal::DelayAllocation);
+ auto result = ::fidl::DecodeAs<OnOpenResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_open(std::move(message->s), std::move(message->info));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool DatagramSocket::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDatagramSocket_Clone_Ordinal:
+ case kDatagramSocket_Clone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Clone(std::move(message->flags), std::move(message->object),
+ Interface::CloneCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_Close_Ordinal:
+ case kDatagramSocket_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_Describe_Ordinal:
+ case kDatagramSocket_Describe_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DescribeRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Describe(
+ Interface::DescribeCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_Sync_Ordinal:
+ case kDatagramSocket_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_GetAttr_Ordinal:
+ case kDatagramSocket_GetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetAttr(
+ Interface::GetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_SetAttr_Ordinal:
+ case kDatagramSocket_SetAttr_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetAttrRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetAttr(std::move(message->flags), std::move(message->attributes),
+ Interface::SetAttrCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_NodeGetFlags_Ordinal:
+ case kDatagramSocket_NodeGetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeGetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NodeGetFlags(
+ Interface::NodeGetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_NodeSetFlags_Ordinal:
+ case kDatagramSocket_NodeSetFlags_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NodeSetFlagsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->NodeSetFlags(std::move(message->flags),
+ Interface::NodeSetFlagsCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_Bind_Ordinal:
+ case kDatagramSocket_Bind_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Bind(std::move(message->addr),
+ Interface::BindCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_Connect_Ordinal:
+ case kDatagramSocket_Connect_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConnectRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Connect(std::move(message->addr),
+ Interface::ConnectCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_GetSockName_Ordinal:
+ case kDatagramSocket_GetSockName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSockNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetSockName(
+ Interface::GetSockNameCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_GetPeerName_Ordinal:
+ case kDatagramSocket_GetPeerName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPeerNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetPeerName(
+ Interface::GetPeerNameCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_SetSockOpt_Ordinal:
+ case kDatagramSocket_SetSockOpt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetSockOptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetSockOpt(std::move(message->level), std::move(message->optname), std::move(message->optval),
+ Interface::SetSockOptCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_GetSockOpt_Ordinal:
+ case kDatagramSocket_GetSockOpt_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetSockOptRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->GetSockOpt(std::move(message->level), std::move(message->optname),
+ Interface::GetSockOptCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_Shutdown_Ordinal:
+ case kDatagramSocket_Shutdown_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ShutdownRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Shutdown(std::move(message->how),
+ Interface::ShutdownCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_RecvMsg_Ordinal:
+ case kDatagramSocket_RecvMsg_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RecvMsgRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RecvMsg(std::move(message->addr_len), std::move(message->data_len), std::move(message->control_len), std::move(message->flags),
+ Interface::RecvMsgCompleter::Sync(txn));
+ return true;
+ }
+ case kDatagramSocket_SendMsg_Ordinal:
+ case kDatagramSocket_SendMsg_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SendMsgRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SendMsg(std::move(message->addr), std::move(message->data), std::move(message->control), std::move(message->flags),
+ Interface::SendMsgCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DatagramSocket::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DatagramSocket::Interface::CloseCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ DatagramSocket::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void DatagramSocket::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ DatagramSocket::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void DatagramSocket::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::DescribeCompleterBase::Reply(::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DescribeResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ DescribeResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DatagramSocket::Interface::DescribeCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < DescribeResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ DescribeResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::DescribeResponse(
+ ::fidl::DecodedMessage<DescribeResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DescribeResponse::PrimarySize,
+ DescribeResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DatagramSocket::Interface::DescribeCompleterBase::Reply(::fidl::DecodedMessage<DescribeResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::DescribeResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+zx_status_t DatagramSocket::SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnOpenResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ OnOpenResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t DatagramSocket::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info) {
+ if (_buffer.capacity() < OnOpenResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnOpenResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::OnOpenResponse(
+ ::fidl::DecodedMessage<OnOpenResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnOpenResponse::PrimarySize,
+ OnOpenResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t DatagramSocket::SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::OnOpenResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+void DatagramSocket::Interface::SyncCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ DatagramSocket::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+void DatagramSocket::Interface::SyncCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SyncResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SyncResponse*>(_buffer.data());
+ DatagramSocket::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_buffer)));
+}
+
+void DatagramSocket::Interface::SyncCompleterBase::Reply(::fidl::DecodedMessage<SyncResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::SyncResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::GetAttrCompleterBase::Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_write_bytes);
+ DatagramSocket::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_response_bytes)));
+}
+
+void DatagramSocket::Interface::GetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes) {
+ if (_buffer.capacity() < GetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetAttrResponse*>(_buffer.data());
+ DatagramSocket::SetTransactionHeaderFor::GetAttrResponse(
+ ::fidl::DecodedMessage<GetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetAttrResponse::PrimarySize,
+ GetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.attributes = std::move(attributes);
+ _buffer.set_actual(sizeof(GetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetAttrResponse>(std::move(_buffer)));
+}
+
+void DatagramSocket::Interface::GetAttrCompleterBase::Reply(::fidl::DecodedMessage<GetAttrResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::GetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::SetAttrCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetAttrResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_write_bytes);
+ DatagramSocket::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_response_bytes)));
+}
+
+void DatagramSocket::Interface::SetAttrCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < SetAttrResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<SetAttrResponse*>(_buffer.data());
+ DatagramSocket::SetTransactionHeaderFor::SetAttrResponse(
+ ::fidl::DecodedMessage<SetAttrResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetAttrResponse::PrimarySize,
+ SetAttrResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(SetAttrResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SetAttrResponse>(std::move(_buffer)));
+}
+
+void DatagramSocket::Interface::SetAttrCompleterBase::Reply(::fidl::DecodedMessage<SetAttrResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::SetAttrResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::NodeGetFlagsCompleterBase::Reply(int32_t s, uint32_t flags) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeGetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_write_bytes);
+ DatagramSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void DatagramSocket::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags) {
+ if (_buffer.capacity() < NodeGetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeGetFlagsResponse*>(_buffer.data());
+ DatagramSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(
+ ::fidl::DecodedMessage<NodeGetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeGetFlagsResponse::PrimarySize,
+ NodeGetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.flags = std::move(flags);
+ _buffer.set_actual(sizeof(NodeGetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeGetFlagsResponse>(std::move(_buffer)));
+}
+
+void DatagramSocket::Interface::NodeGetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::NodeSetFlagsCompleterBase::Reply(int32_t s) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NodeSetFlagsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_write_bytes);
+ DatagramSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_response_bytes)));
+}
+
+void DatagramSocket::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s) {
+ if (_buffer.capacity() < NodeSetFlagsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<NodeSetFlagsResponse*>(_buffer.data());
+ DatagramSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(
+ ::fidl::DecodedMessage<NodeSetFlagsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ NodeSetFlagsResponse::PrimarySize,
+ NodeSetFlagsResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _buffer.set_actual(sizeof(NodeSetFlagsResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<NodeSetFlagsResponse>(std::move(_buffer)));
+}
+
+void DatagramSocket::Interface::NodeSetFlagsCompleterBase::Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::BindCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ BindResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::BindCompleterBase::ReplySuccess() {
+ BaseSocket_Bind_Response response;
+
+ Reply(BaseSocket_Bind_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::BindCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_Bind_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::BindCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result) {
+ if (_buffer.capacity() < BindResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ BindResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::BindResponse(
+ ::fidl::DecodedMessage<BindResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ BindResponse::PrimarySize,
+ BindResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::BindCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_Bind_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_Bind_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::BindCompleterBase::Reply(::fidl::DecodedMessage<BindResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::BindResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::ConnectCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ConnectResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::ConnectCompleterBase::ReplySuccess() {
+ BaseSocket_Connect_Response response;
+
+ Reply(BaseSocket_Connect_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::ConnectCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_Connect_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::ConnectCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result) {
+ if (_buffer.capacity() < ConnectResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ConnectResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::ConnectResponse(
+ ::fidl::DecodedMessage<ConnectResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConnectResponse::PrimarySize,
+ ConnectResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::ConnectCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_Connect_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_Connect_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::ConnectCompleterBase::Reply(::fidl::DecodedMessage<ConnectResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::ConnectResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::GetSockNameCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetSockNameResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::GetSockNameResponse(
+ ::fidl::DecodedMessage<GetSockNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockNameResponse::PrimarySize,
+ GetSockNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::GetSockNameCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetSockName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(BaseSocket_GetSockName_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::GetSockNameCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetSockName_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::GetSockNameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result) {
+ if (_buffer.capacity() < GetSockNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSockNameResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::GetSockNameResponse(
+ ::fidl::DecodedMessage<GetSockNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockNameResponse::PrimarySize,
+ GetSockNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::GetSockNameCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetSockName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(std::move(_buffer), BaseSocket_GetSockName_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::GetSockNameCompleterBase::Reply(::fidl::DecodedMessage<GetSockNameResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::GetSockNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::GetPeerNameCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPeerNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetPeerNameResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::GetPeerNameResponse(
+ ::fidl::DecodedMessage<GetPeerNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPeerNameResponse::PrimarySize,
+ GetPeerNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::GetPeerNameCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetPeerName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(BaseSocket_GetPeerName_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::GetPeerNameCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetPeerName_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::GetPeerNameCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result) {
+ if (_buffer.capacity() < GetPeerNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPeerNameResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::GetPeerNameResponse(
+ ::fidl::DecodedMessage<GetPeerNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPeerNameResponse::PrimarySize,
+ GetPeerNameResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::GetPeerNameCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr) {
+ BaseSocket_GetPeerName_Response response;
+ response.addr = std::move(addr);
+
+ Reply(std::move(_buffer), BaseSocket_GetPeerName_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::GetPeerNameCompleterBase::Reply(::fidl::DecodedMessage<GetPeerNameResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::GetPeerNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::SetSockOptCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetSockOptResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SetSockOptResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::SetSockOptResponse(
+ ::fidl::DecodedMessage<SetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSockOptResponse::PrimarySize,
+ SetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::SetSockOptCompleterBase::ReplySuccess() {
+ BaseSocket_SetSockOpt_Response response;
+
+ Reply(BaseSocket_SetSockOpt_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::SetSockOptCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_SetSockOpt_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::SetSockOptCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result) {
+ if (_buffer.capacity() < SetSockOptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SetSockOptResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::SetSockOptResponse(
+ ::fidl::DecodedMessage<SetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetSockOptResponse::PrimarySize,
+ SetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::SetSockOptCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ BaseSocket_SetSockOpt_Response response;
+
+ Reply(std::move(_buffer), BaseSocket_SetSockOpt_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::SetSockOptCompleterBase::Reply(::fidl::DecodedMessage<SetSockOptResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::SetSockOptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::GetSockOptCompleterBase::Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetSockOptResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetSockOptResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::GetSockOptResponse(
+ ::fidl::DecodedMessage<GetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockOptResponse::PrimarySize,
+ GetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::GetSockOptCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> optval) {
+ BaseSocket_GetSockOpt_Response response;
+ response.optval = std::move(optval);
+
+ Reply(BaseSocket_GetSockOpt_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::GetSockOptCompleterBase::ReplyError(int32_t error) {
+ Reply(BaseSocket_GetSockOpt_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::GetSockOptCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result) {
+ if (_buffer.capacity() < GetSockOptResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetSockOptResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::GetSockOptResponse(
+ ::fidl::DecodedMessage<GetSockOptResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetSockOptResponse::PrimarySize,
+ GetSockOptResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::GetSockOptCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> optval) {
+ BaseSocket_GetSockOpt_Response response;
+ response.optval = std::move(optval);
+
+ Reply(std::move(_buffer), BaseSocket_GetSockOpt_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::GetSockOptCompleterBase::Reply(::fidl::DecodedMessage<GetSockOptResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::GetSockOptResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::ShutdownCompleterBase::Reply(::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShutdownResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ShutdownResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::ShutdownResponse(
+ ::fidl::DecodedMessage<ShutdownResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ShutdownResponse::PrimarySize,
+ ShutdownResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::ShutdownCompleterBase::ReplySuccess() {
+ DatagramSocket_Shutdown_Response response;
+
+ Reply(DatagramSocket_Shutdown_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::ShutdownCompleterBase::ReplyError(int32_t error) {
+ Reply(DatagramSocket_Shutdown_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::ShutdownCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Result result) {
+ if (_buffer.capacity() < ShutdownResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ShutdownResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::ShutdownResponse(
+ ::fidl::DecodedMessage<ShutdownResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ShutdownResponse::PrimarySize,
+ ShutdownResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::ShutdownCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ DatagramSocket_Shutdown_Response response;
+
+ Reply(std::move(_buffer), DatagramSocket_Shutdown_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::ShutdownCompleterBase::Reply(::fidl::DecodedMessage<ShutdownResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::ShutdownResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::RecvMsgCompleterBase::Reply(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RecvMsgResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ RecvMsgResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::RecvMsgResponse(
+ ::fidl::DecodedMessage<RecvMsgResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RecvMsgResponse::PrimarySize,
+ RecvMsgResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::RecvMsgCompleterBase::ReplySuccess(::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<uint8_t> data, ::fidl::VectorView<uint8_t> control, uint32_t truncated) {
+ DatagramSocket_RecvMsg_Response response;
+ response.addr = std::move(addr);
+ response.data = std::move(data);
+ response.control = std::move(control);
+ response.truncated = std::move(truncated);
+
+ Reply(DatagramSocket_RecvMsg_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::RecvMsgCompleterBase::ReplyError(int32_t error) {
+ Reply(DatagramSocket_RecvMsg_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::RecvMsgCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Result result) {
+ if (_buffer.capacity() < RecvMsgResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ RecvMsgResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::RecvMsgResponse(
+ ::fidl::DecodedMessage<RecvMsgResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ RecvMsgResponse::PrimarySize,
+ RecvMsgResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::RecvMsgCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<uint8_t> data, ::fidl::VectorView<uint8_t> control, uint32_t truncated) {
+ DatagramSocket_RecvMsg_Response response;
+ response.addr = std::move(addr);
+ response.data = std::move(data);
+ response.control = std::move(control);
+ response.truncated = std::move(truncated);
+
+ Reply(std::move(_buffer), DatagramSocket_RecvMsg_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::RecvMsgCompleterBase::Reply(::fidl::DecodedMessage<RecvMsgResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::RecvMsgResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DatagramSocket::Interface::SendMsgCompleterBase::Reply(::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SendMsgResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SendMsgResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::SendMsgResponse(
+ ::fidl::DecodedMessage<SendMsgResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SendMsgResponse::PrimarySize,
+ SendMsgResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::SendMsgCompleterBase::ReplySuccess(int64_t len) {
+ DatagramSocket_SendMsg_Response response;
+ response.len = std::move(len);
+
+ Reply(DatagramSocket_SendMsg_Result::WithResponse(&response));
+}
+void DatagramSocket::Interface::SendMsgCompleterBase::ReplyError(int32_t error) {
+ Reply(DatagramSocket_SendMsg_Result::WithErr(&error));
+}
+
+void DatagramSocket::Interface::SendMsgCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Result result) {
+ if (_buffer.capacity() < SendMsgResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SendMsgResponse _response = {};
+ DatagramSocket::SetTransactionHeaderFor::SendMsgResponse(
+ ::fidl::DecodedMessage<SendMsgResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SendMsgResponse::PrimarySize,
+ SendMsgResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void DatagramSocket::Interface::SendMsgCompleterBase::ReplySuccess(::fidl::BytePart _buffer, int64_t len) {
+ DatagramSocket_SendMsg_Response response;
+ response.len = std::move(len);
+
+ Reply(std::move(_buffer), DatagramSocket_SendMsg_Result::WithResponse(&response));
+}
+
+void DatagramSocket::Interface::SendMsgCompleterBase::Reply(::fidl::DecodedMessage<SendMsgResponse> params) {
+ DatagramSocket::SetTransactionHeaderFor::SendMsgResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void DatagramSocket::SetTransactionHeaderFor::CloneRequest(const ::fidl::DecodedMessage<DatagramSocket::CloneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Clone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<DatagramSocket::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<DatagramSocket::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::DescribeRequest(const ::fidl::DecodedMessage<DatagramSocket::DescribeRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::DescribeResponse(const ::fidl::DecodedMessage<DatagramSocket::DescribeResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Describe_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::OnOpenResponse(const ::fidl::DecodedMessage<DatagramSocket::OnOpenResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_OnOpen_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<DatagramSocket::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<DatagramSocket::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::GetAttrRequest(const ::fidl::DecodedMessage<DatagramSocket::GetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::GetAttrResponse(const ::fidl::DecodedMessage<DatagramSocket::GetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_GetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::SetAttrRequest(const ::fidl::DecodedMessage<DatagramSocket::SetAttrRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::SetAttrResponse(const ::fidl::DecodedMessage<DatagramSocket::SetAttrResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_SetAttr_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::NodeGetFlagsRequest(const ::fidl::DecodedMessage<DatagramSocket::NodeGetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::NodeGetFlagsResponse(const ::fidl::DecodedMessage<DatagramSocket::NodeGetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_NodeGetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::NodeSetFlagsRequest(const ::fidl::DecodedMessage<DatagramSocket::NodeSetFlagsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::NodeSetFlagsResponse(const ::fidl::DecodedMessage<DatagramSocket::NodeSetFlagsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_NodeSetFlags_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::BindRequest(const ::fidl::DecodedMessage<DatagramSocket::BindRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::BindResponse(const ::fidl::DecodedMessage<DatagramSocket::BindResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Bind_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::ConnectRequest(const ::fidl::DecodedMessage<DatagramSocket::ConnectRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::ConnectResponse(const ::fidl::DecodedMessage<DatagramSocket::ConnectResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::GetSockNameRequest(const ::fidl::DecodedMessage<DatagramSocket::GetSockNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_GetSockName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::GetSockNameResponse(const ::fidl::DecodedMessage<DatagramSocket::GetSockNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_GetSockName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::GetPeerNameRequest(const ::fidl::DecodedMessage<DatagramSocket::GetPeerNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_GetPeerName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::GetPeerNameResponse(const ::fidl::DecodedMessage<DatagramSocket::GetPeerNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_GetPeerName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::SetSockOptRequest(const ::fidl::DecodedMessage<DatagramSocket::SetSockOptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_SetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::SetSockOptResponse(const ::fidl::DecodedMessage<DatagramSocket::SetSockOptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_SetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::GetSockOptRequest(const ::fidl::DecodedMessage<DatagramSocket::GetSockOptRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_GetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::GetSockOptResponse(const ::fidl::DecodedMessage<DatagramSocket::GetSockOptResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_GetSockOpt_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::ShutdownRequest(const ::fidl::DecodedMessage<DatagramSocket::ShutdownRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Shutdown_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::ShutdownResponse(const ::fidl::DecodedMessage<DatagramSocket::ShutdownResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_Shutdown_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::RecvMsgRequest(const ::fidl::DecodedMessage<DatagramSocket::RecvMsgRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_RecvMsg_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::RecvMsgResponse(const ::fidl::DecodedMessage<DatagramSocket::RecvMsgResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_RecvMsg_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DatagramSocket::SetTransactionHeaderFor::SendMsgRequest(const ::fidl::DecodedMessage<DatagramSocket::SendMsgRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_SendMsg_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DatagramSocket::SetTransactionHeaderFor::SendMsgResponse(const ::fidl::DecodedMessage<DatagramSocket::SendMsgResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDatagramSocket_SendMsg_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace socket
+} // namespace posix
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-posix-socket/gen/llcpp/include/fuchsia/posix/socket/llcpp/fidl.h b/zircon/system/fidl/fuchsia-posix-socket/gen/llcpp/include/fuchsia/posix/socket/llcpp/fidl.h
new file mode 100644
index 0000000..518f57d2
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-posix-socket/gen/llcpp/include/fuchsia/posix/socket/llcpp/fidl.h
@@ -0,0 +1,10068 @@
+// 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 <zircon/fidl.h>
+
+#include <fuchsia/io/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace posix {
+namespace socket {
+
+struct BaseSocket_GetSockOpt_Response;
+struct BaseSocket_GetSockOpt_Result;
+struct DatagramSocket_RecvMsg_Response;
+struct DatagramSocket_RecvMsg_Result;
+struct BaseSocket_GetSockName_Response;
+struct BaseSocket_GetSockName_Result;
+struct BaseSocket_GetPeerName_Response;
+struct BaseSocket_GetPeerName_Result;
+struct StreamSocket_Listen_Response;
+struct StreamSocket_Listen_Result;
+struct StreamSocket_Accept_Response;
+struct StreamSocket_Accept_Result;
+struct Provider_Socket2_Response;
+struct Provider_Socket2_Result;
+class Provider;
+struct DatagramSocket_Shutdown_Response;
+struct DatagramSocket_Shutdown_Result;
+struct DatagramSocket_SendMsg_Response;
+struct DatagramSocket_SendMsg_Result;
+struct BaseSocket_SetSockOpt_Response;
+struct BaseSocket_SetSockOpt_Result;
+struct BaseSocket_Connect_Response;
+struct BaseSocket_Connect_Result;
+struct BaseSocket_Bind_Response;
+struct BaseSocket_Bind_Result;
+class Control;
+class BaseSocket;
+class StreamSocket;
+class DatagramSocket;
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_GetSockOpt_ResultTable;
+
+struct BaseSocket_GetSockOpt_Result {
+ BaseSocket_GetSockOpt_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static BaseSocket_GetSockOpt_Result WithResponse(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response* val) {
+ BaseSocket_GetSockOpt_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static BaseSocket_GetSockOpt_Result WithErr(int32_t* val) {
+ BaseSocket_GetSockOpt_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_GetSockOpt_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 920;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocket_RecvMsg_ResultTable;
+
+struct DatagramSocket_RecvMsg_Result {
+ DatagramSocket_RecvMsg_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static DatagramSocket_RecvMsg_Result WithResponse(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response* val) {
+ DatagramSocket_RecvMsg_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static DatagramSocket_RecvMsg_Result WithErr(int32_t* val) {
+ DatagramSocket_RecvMsg_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocket_RecvMsg_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_GetSockName_ResultTable;
+
+struct BaseSocket_GetSockName_Result {
+ BaseSocket_GetSockName_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static BaseSocket_GetSockName_Result WithResponse(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response* val) {
+ BaseSocket_GetSockName_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static BaseSocket_GetSockName_Result WithErr(int32_t* val) {
+ BaseSocket_GetSockName_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_GetSockName_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_GetPeerName_ResultTable;
+
+struct BaseSocket_GetPeerName_Result {
+ BaseSocket_GetPeerName_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static BaseSocket_GetPeerName_Result WithResponse(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response* val) {
+ BaseSocket_GetPeerName_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static BaseSocket_GetPeerName_Result WithErr(int32_t* val) {
+ BaseSocket_GetPeerName_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_GetPeerName_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocket_Listen_ResultTable;
+
+struct StreamSocket_Listen_Result {
+ StreamSocket_Listen_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static StreamSocket_Listen_Result WithResponse(::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response* val) {
+ StreamSocket_Listen_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static StreamSocket_Listen_Result WithErr(int32_t* val) {
+ StreamSocket_Listen_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocket_Listen_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocket_Accept_ResultTable;
+
+struct StreamSocket_Accept_Result {
+ StreamSocket_Accept_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static StreamSocket_Accept_Result WithResponse(::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response* val) {
+ StreamSocket_Accept_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static StreamSocket_Accept_Result WithErr(int32_t* val) {
+ StreamSocket_Accept_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocket_Accept_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_Provider_Socket2_ResultTable;
+
+struct Provider_Socket2_Result {
+ Provider_Socket2_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static Provider_Socket2_Result WithResponse(::llcpp::fuchsia::posix::socket::Provider_Socket2_Response* val) {
+ Provider_Socket2_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::Provider_Socket2_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::Provider_Socket2_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::Provider_Socket2_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::Provider_Socket2_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::Provider_Socket2_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static Provider_Socket2_Result WithErr(int32_t* val) {
+ Provider_Socket2_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_Provider_Socket2_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocket_Shutdown_ResultTable;
+
+struct DatagramSocket_Shutdown_Result {
+ DatagramSocket_Shutdown_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static DatagramSocket_Shutdown_Result WithResponse(::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response* val) {
+ DatagramSocket_Shutdown_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static DatagramSocket_Shutdown_Result WithErr(int32_t* val) {
+ DatagramSocket_Shutdown_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocket_Shutdown_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocket_SendMsg_ResultTable;
+
+struct DatagramSocket_SendMsg_Result {
+ DatagramSocket_SendMsg_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static DatagramSocket_SendMsg_Result WithResponse(::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response* val) {
+ DatagramSocket_SendMsg_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static DatagramSocket_SendMsg_Result WithErr(int32_t* val) {
+ DatagramSocket_SendMsg_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocket_SendMsg_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_SetSockOpt_ResultTable;
+
+struct BaseSocket_SetSockOpt_Result {
+ BaseSocket_SetSockOpt_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static BaseSocket_SetSockOpt_Result WithResponse(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response* val) {
+ BaseSocket_SetSockOpt_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static BaseSocket_SetSockOpt_Result WithErr(int32_t* val) {
+ BaseSocket_SetSockOpt_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_SetSockOpt_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_Connect_ResultTable;
+
+struct BaseSocket_Connect_Result {
+ BaseSocket_Connect_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static BaseSocket_Connect_Result WithResponse(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response* val) {
+ BaseSocket_Connect_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static BaseSocket_Connect_Result WithErr(int32_t* val) {
+ BaseSocket_Connect_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_Connect_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_Bind_ResultTable;
+
+struct BaseSocket_Bind_Result {
+ BaseSocket_Bind_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static BaseSocket_Bind_Result WithResponse(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response* val) {
+ BaseSocket_Bind_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static BaseSocket_Bind_Result WithErr(int32_t* val) {
+ BaseSocket_Bind_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_Bind_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_GetSockOpt_ResponseTable;
+
+struct BaseSocket_GetSockOpt_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_GetSockOpt_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 904;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint8_t> optval = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocket_RecvMsg_ResponseTable;
+
+struct DatagramSocket_RecvMsg_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocket_RecvMsg_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint8_t> addr = {};
+
+ ::fidl::VectorView<uint8_t> data = {};
+
+ ::fidl::VectorView<uint8_t> control = {};
+
+ uint32_t truncated = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_GetSockName_ResponseTable;
+
+struct BaseSocket_GetSockName_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_GetSockName_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 128;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint8_t> addr = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_GetPeerName_ResponseTable;
+
+struct BaseSocket_GetPeerName_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_GetPeerName_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 128;
+ static constexpr bool HasPointer = true;
+
+ ::fidl::VectorView<uint8_t> addr = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocket_Listen_ResponseTable;
+
+struct StreamSocket_Listen_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocket_Listen_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocket_Accept_ResponseTable;
+
+struct StreamSocket_Accept_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocket_Accept_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::channel s = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_Provider_Socket2_ResponseTable;
+
+struct Provider_Socket2_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_Provider_Socket2_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::zx::channel s = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ProviderSocketRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ProviderSocketResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ProviderSocket2RequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ProviderSocket2ResponseTable;
+
+// Provider implements the POSIX sockets API.
+class Provider final {
+ Provider() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.posix.socket.Provider";
+
+ struct SocketResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+ ::zx::channel s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ProviderSocketResponseTable;
+ 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;
+ };
+ struct SocketRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t domain;
+ int16_t type;
+ int16_t protocol;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ProviderSocketRequestTable;
+ 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 = SocketResponse;
+ };
+
+ struct Socket2Response final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::Provider_Socket2_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ProviderSocket2ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct Socket2Request final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t domain;
+ int16_t type;
+ int16_t protocol;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ProviderSocket2RequestTable;
+ 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 = Socket2Response;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Socket_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Socket_Impl(::zx::unowned_channel _client_end, int16_t domain, int16_t type, int16_t protocol);
+ ~Socket_Impl() = default;
+ Socket_Impl(Socket_Impl&& other) = default;
+ Socket_Impl& operator=(Socket_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 Socket2_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Socket2_Impl(::zx::unowned_channel _client_end, int16_t domain, int16_t type, int16_t protocol);
+ ~Socket2_Impl() = default;
+ Socket2_Impl(Socket2_Impl&& other) = default;
+ Socket2_Impl& operator=(Socket2_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 Socket = Socket_Impl<SocketResponse>;
+ using Socket2 = Socket2_Impl<Socket2Response>;
+ };
+
+ // 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 Socket_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Socket_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer);
+ ~Socket_Impl() = default;
+ Socket_Impl(Socket_Impl&& other) = default;
+ Socket_Impl& operator=(Socket_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 Socket2_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Socket2_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer);
+ ~Socket2_Impl() = default;
+ Socket2_Impl(Socket2_Impl&& other) = default;
+ Socket2_Impl& operator=(Socket2_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 Socket = Socket_Impl<SocketResponse>;
+ using Socket2 = Socket2_Impl<Socket2Response>;
+ };
+
+ 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_; }
+
+ // Requests a socket with the specified parameters. Values for `code` are defined in errno.h.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Socket Socket(int16_t domain, int16_t type, int16_t protocol);
+
+ // Requests a socket with the specified parameters. Values for `code` are defined in errno.h.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Socket Socket(::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer);
+
+ // Requests a socket with the specified parameters. Error values are defined in errno.h.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Socket2 Socket2(int16_t domain, int16_t type, int16_t protocol);
+
+ // Requests a socket with the specified parameters. Error values are defined in errno.h.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Socket2 Socket2(::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::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:
+
+ // Requests a socket with the specified parameters. Values for `code` are defined in errno.h.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Socket Socket(::zx::unowned_channel _client_end, int16_t domain, int16_t type, int16_t protocol);
+
+ // Requests a socket with the specified parameters. Values for `code` are defined in errno.h.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Socket Socket(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::fidl::BytePart _response_buffer);
+
+ // Requests a socket with the specified parameters. Error values are defined in errno.h.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Socket2 Socket2(::zx::unowned_channel _client_end, int16_t domain, int16_t type, int16_t protocol);
+
+ // Requests a socket with the specified parameters. Error values are defined in errno.h.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Socket2 Socket2(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t domain, int16_t type, int16_t protocol, ::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:
+
+ // Requests a socket with the specified parameters. Values for `code` are defined in errno.h.
+ static ::fidl::DecodeResult<SocketResponse> Socket(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SocketRequest> params, ::fidl::BytePart response_buffer);
+
+ // Requests a socket with the specified parameters. Error values are defined in errno.h.
+ static ::fidl::DecodeResult<Socket2Response> Socket2(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<Socket2Request> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Provider;
+ using _Base = ::fidl::CompleterBase;
+
+ class SocketCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code, ::zx::channel s);
+ void Reply(::fidl::BytePart _buffer, int16_t code, ::zx::channel s);
+ void Reply(::fidl::DecodedMessage<SocketResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SocketCompleter = ::fidl::Completer<SocketCompleterBase>;
+
+ virtual void Socket(int16_t domain, int16_t type, int16_t protocol, SocketCompleter::Sync _completer) = 0;
+
+ class Socket2CompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::Provider_Socket2_Result result);
+ void ReplySuccess(::zx::channel s);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::Provider_Socket2_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::channel s);
+ void Reply(::fidl::DecodedMessage<Socket2Response> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using Socket2Completer = ::fidl::Completer<Socket2CompleterBase>;
+
+ virtual void Socket2(int16_t domain, int16_t type, int16_t protocol, Socket2Completer::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 SocketRequest(const ::fidl::DecodedMessage<Provider::SocketRequest>& _msg);
+ static void SocketResponse(const ::fidl::DecodedMessage<Provider::SocketResponse>& _msg);
+ static void Socket2Request(const ::fidl::DecodedMessage<Provider::Socket2Request>& _msg);
+ static void Socket2Response(const ::fidl::DecodedMessage<Provider::Socket2Response>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocket_Shutdown_ResponseTable;
+
+struct DatagramSocket_Shutdown_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocket_Shutdown_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocket_SendMsg_ResponseTable;
+
+struct DatagramSocket_SendMsg_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocket_SendMsg_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ int64_t len = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_SetSockOpt_ResponseTable;
+
+struct BaseSocket_SetSockOpt_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_SetSockOpt_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_Connect_ResponseTable;
+
+struct BaseSocket_Connect_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_Connect_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocket_Bind_ResponseTable;
+
+struct BaseSocket_Bind_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocket_Bind_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlBindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlConnectResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlListenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlListenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlAcceptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlAcceptResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetSockNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetSockNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetPeerNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetPeerNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlSetSockOptResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_ControlGetSockOptResponseTable;
+
+// The control plane for a network socket.
+//
+// Once a socket has been retrieved from a `Provider`, this interface is then used to further
+// configure and use the socket. This interface is essentially POSIX. Its implementation must
+// support Linux-specific arguments to {Get,Set}SockOpt.
+//
+// *Warning:* This protocol is not yet ready for direct use by clients. Instead, clients should
+// use the BSD sockets API to interact with sockets. We plan to change this protocol substantially
+// and clients that couple directly to this protocol will make those changes more difficult.
+class Control final {
+ Control() = delete;
+ public:
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct BindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlBindResponseTable;
+ 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 BindRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlBindRequestTable;
+ 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 = BindResponse;
+ };
+
+ struct ConnectResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlConnectResponseTable;
+ 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 ConnectRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlConnectRequestTable;
+ 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 = ConnectResponse;
+ };
+
+ struct ListenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlListenResponseTable;
+ 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 ListenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t backlog;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlListenRequestTable;
+ 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 = ListenResponse;
+ };
+
+ struct AcceptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+ ::zx::channel s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlAcceptResponseTable;
+ 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;
+ };
+ struct AcceptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlAcceptRequestTable;
+ 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 = AcceptResponse;
+ };
+
+ struct GetSockNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlGetSockNameResponseTable;
+ 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 GetSockNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetPeerNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlGetPeerNameResponseTable;
+ 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 GetPeerNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetSockOptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlSetSockOptResponseTable;
+ 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 SetSockOptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t level;
+ int16_t optname;
+ ::fidl::VectorView<uint8_t> optval;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlSetSockOptRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 904;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 904;
+ 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 = SetSockOptResponse;
+ };
+
+ struct GetSockOptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t code;
+ ::fidl::VectorView<uint8_t> optval;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlGetSockOptResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 904;
+ 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 GetSockOptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t level;
+ int16_t optname;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_ControlGetSockOptRequestTable;
+ 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 = GetSockOptResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Bind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Connect_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 Listen_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Listen_Impl(::zx::unowned_channel _client_end, int16_t backlog);
+ ~Listen_Impl() = default;
+ Listen_Impl(Listen_Impl&& other) = default;
+ Listen_Impl& operator=(Listen_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 Accept_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Accept_Impl(::zx::unowned_channel _client_end, int16_t flags);
+ ~Accept_Impl() = default;
+ Accept_Impl(Accept_Impl&& other) = default;
+ Accept_Impl& operator=(Accept_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 GetSockName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSockName_Impl(::zx::unowned_channel _client_end);
+ ~GetSockName_Impl() = default;
+ GetSockName_Impl(GetSockName_Impl&& other) = default;
+ GetSockName_Impl& operator=(GetSockName_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 GetPeerName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetPeerName_Impl(::zx::unowned_channel _client_end);
+ ~GetPeerName_Impl() = default;
+ GetPeerName_Impl(GetPeerName_Impl&& other) = default;
+ GetPeerName_Impl& operator=(GetPeerName_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 SetSockOpt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+ ~SetSockOpt_Impl() = default;
+ SetSockOpt_Impl(SetSockOpt_Impl&& other) = default;
+ SetSockOpt_Impl& operator=(SetSockOpt_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 GetSockOpt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname);
+ ~GetSockOpt_Impl() = default;
+ GetSockOpt_Impl(GetSockOpt_Impl&& other) = default;
+ GetSockOpt_Impl& operator=(GetSockOpt_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Bind = Bind_Impl<BindResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using Listen = Listen_Impl<ListenResponse>;
+ using Accept = Accept_Impl<AcceptResponse>;
+ using GetSockName = GetSockName_Impl<GetSockNameResponse>;
+ using GetPeerName = GetPeerName_Impl<GetPeerNameResponse>;
+ using SetSockOpt = SetSockOpt_Impl<SetSockOptResponse>;
+ using GetSockOpt = GetSockOpt_Impl<GetSockOptResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Bind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Connect_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 Listen_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Listen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer);
+ ~Listen_Impl() = default;
+ Listen_Impl(Listen_Impl&& other) = default;
+ Listen_Impl& operator=(Listen_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 Accept_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Accept_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer);
+ ~Accept_Impl() = default;
+ Accept_Impl(Accept_Impl&& other) = default;
+ Accept_Impl& operator=(Accept_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 GetSockName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSockName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetSockName_Impl() = default;
+ GetSockName_Impl(GetSockName_Impl&& other) = default;
+ GetSockName_Impl& operator=(GetSockName_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 GetPeerName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetPeerName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetPeerName_Impl() = default;
+ GetPeerName_Impl(GetPeerName_Impl&& other) = default;
+ GetPeerName_Impl& operator=(GetPeerName_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 SetSockOpt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+ ~SetSockOpt_Impl() = default;
+ SetSockOpt_Impl(SetSockOpt_Impl&& other) = default;
+ SetSockOpt_Impl& operator=(SetSockOpt_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 GetSockOpt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+ ~GetSockOpt_Impl() = default;
+ GetSockOpt_Impl(GetSockOpt_Impl&& other) = default;
+ GetSockOpt_Impl& operator=(GetSockOpt_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Bind = Bind_Impl<BindResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using Listen = Listen_Impl<ListenResponse>;
+ using Accept = Accept_Impl<AcceptResponse>;
+ using GetSockName = GetSockName_Impl<GetSockNameResponse>;
+ using GetPeerName = GetPeerName_Impl<GetPeerNameResponse>;
+ using SetSockOpt = SetSockOpt_Impl<SetSockOptResponse>;
+ using GetSockOpt = GetSockOpt_Impl<GetSockOptResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sets the local address used for the socket.
+ // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Bind Bind(::fidl::VectorView<uint8_t> addr);
+
+ // Sets the local address used for the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Bind Bind(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Initiates a connection to a remote address.
+ // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Connect Connect(::fidl::VectorView<uint8_t> addr);
+
+ // Initiates a connection to a remote address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Connect Connect(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Listen Listen(int16_t backlog);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Listen Listen(::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer);
+
+ // Accepts a buffered incoming connection.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Accept Accept(int16_t flags);
+
+ // Accepts a buffered incoming connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Accept Accept(::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the local socket address.
+ // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetSockName GetSockName();
+
+ // Retrieves the local socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSockName GetSockName(::fidl::BytePart _response_buffer);
+
+ // Retrieves the remote socket address.
+ // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetPeerName GetPeerName();
+
+ // Retrieves the remote socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetPeerName GetPeerName(::fidl::BytePart _response_buffer);
+
+ // Sets the value of a socket option.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SetSockOpt SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+
+ // Sets the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetSockOpt SetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the value of a socket option.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetSockOpt GetSockOpt(int16_t level, int16_t optname);
+
+ // Retrieves the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSockOpt GetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sets the local address used for the socket.
+ // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+
+ // Sets the local address used for the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Initiates a connection to a remote address.
+ // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+
+ // Initiates a connection to a remote address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Listen Listen(::zx::unowned_channel _client_end, int16_t backlog);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Listen Listen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer);
+
+ // Accepts a buffered incoming connection.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Accept Accept(::zx::unowned_channel _client_end, int16_t flags);
+
+ // Accepts a buffered incoming connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Accept Accept(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the local socket address.
+ // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetSockName GetSockName(::zx::unowned_channel _client_end);
+
+ // Retrieves the local socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSockName GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the remote socket address.
+ // Allocates 184 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetPeerName GetPeerName(::zx::unowned_channel _client_end);
+
+ // Retrieves the remote socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetPeerName GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets the value of a socket option.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SetSockOpt SetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+
+ // Sets the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetSockOpt SetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the value of a socket option.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetSockOpt GetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname);
+
+ // Retrieves the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSockOpt GetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Sets the local address used for the socket.
+ static ::fidl::DecodeResult<BindResponse> Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer);
+
+ // Initiates a connection to a remote address.
+ static ::fidl::DecodeResult<ConnectResponse> Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params, ::fidl::BytePart response_buffer);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ static ::fidl::DecodeResult<ListenResponse> Listen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ListenRequest> params, ::fidl::BytePart response_buffer);
+
+ // Accepts a buffered incoming connection.
+ static ::fidl::DecodeResult<AcceptResponse> Accept(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AcceptRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieves the local socket address.
+ static ::fidl::DecodeResult<GetSockNameResponse> GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Retrieves the remote socket address.
+ static ::fidl::DecodeResult<GetPeerNameResponse> GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets the value of a socket option.
+ static ::fidl::DecodeResult<SetSockOptResponse> SetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSockOptRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieves the value of a socket option.
+ static ::fidl::DecodeResult<GetSockOptResponse> GetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSockOptRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Control;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class BindCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code);
+ void Reply(::fidl::BytePart _buffer, int16_t code);
+ void Reply(::fidl::DecodedMessage<BindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BindCompleter = ::fidl::Completer<BindCompleterBase>;
+
+ virtual void Bind(::fidl::VectorView<uint8_t> addr, BindCompleter::Sync _completer) = 0;
+
+ class ConnectCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code);
+ void Reply(::fidl::BytePart _buffer, int16_t code);
+ void Reply(::fidl::DecodedMessage<ConnectResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConnectCompleter = ::fidl::Completer<ConnectCompleterBase>;
+
+ virtual void Connect(::fidl::VectorView<uint8_t> addr, ConnectCompleter::Sync _completer) = 0;
+
+ class ListenCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code);
+ void Reply(::fidl::BytePart _buffer, int16_t code);
+ void Reply(::fidl::DecodedMessage<ListenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ListenCompleter = ::fidl::Completer<ListenCompleterBase>;
+
+ virtual void Listen(int16_t backlog, ListenCompleter::Sync _completer) = 0;
+
+ class AcceptCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code, ::zx::channel s);
+ void Reply(::fidl::BytePart _buffer, int16_t code, ::zx::channel s);
+ void Reply(::fidl::DecodedMessage<AcceptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AcceptCompleter = ::fidl::Completer<AcceptCompleterBase>;
+
+ virtual void Accept(int16_t flags, AcceptCompleter::Sync _completer) = 0;
+
+ class GetSockNameCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::BytePart _buffer, int16_t code, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::DecodedMessage<GetSockNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSockNameCompleter = ::fidl::Completer<GetSockNameCompleterBase>;
+
+ virtual void GetSockName(GetSockNameCompleter::Sync _completer) = 0;
+
+ class GetPeerNameCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::BytePart _buffer, int16_t code, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::DecodedMessage<GetPeerNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPeerNameCompleter = ::fidl::Completer<GetPeerNameCompleterBase>;
+
+ virtual void GetPeerName(GetPeerNameCompleter::Sync _completer) = 0;
+
+ class SetSockOptCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code);
+ void Reply(::fidl::BytePart _buffer, int16_t code);
+ void Reply(::fidl::DecodedMessage<SetSockOptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetSockOptCompleter = ::fidl::Completer<SetSockOptCompleterBase>;
+
+ virtual void SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, SetSockOptCompleter::Sync _completer) = 0;
+
+ class GetSockOptCompleterBase : public _Base {
+ public:
+ void Reply(int16_t code, ::fidl::VectorView<uint8_t> optval);
+ void Reply(::fidl::BytePart _buffer, int16_t code, ::fidl::VectorView<uint8_t> optval);
+ void Reply(::fidl::DecodedMessage<GetSockOptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSockOptCompleter = ::fidl::Completer<GetSockOptCompleterBase>;
+
+ virtual void GetSockOpt(int16_t level, int16_t optname, GetSockOptCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<Control::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Control::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<Control::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<Control::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<Control::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<Control::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<Control::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<Control::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<Control::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<Control::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<Control::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<Control::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<Control::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<Control::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<Control::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<Control::NodeSetFlagsResponse>& _msg);
+ static void BindRequest(const ::fidl::DecodedMessage<Control::BindRequest>& _msg);
+ static void BindResponse(const ::fidl::DecodedMessage<Control::BindResponse>& _msg);
+ static void ConnectRequest(const ::fidl::DecodedMessage<Control::ConnectRequest>& _msg);
+ static void ConnectResponse(const ::fidl::DecodedMessage<Control::ConnectResponse>& _msg);
+ static void ListenRequest(const ::fidl::DecodedMessage<Control::ListenRequest>& _msg);
+ static void ListenResponse(const ::fidl::DecodedMessage<Control::ListenResponse>& _msg);
+ static void AcceptRequest(const ::fidl::DecodedMessage<Control::AcceptRequest>& _msg);
+ static void AcceptResponse(const ::fidl::DecodedMessage<Control::AcceptResponse>& _msg);
+ static void GetSockNameRequest(const ::fidl::DecodedMessage<Control::GetSockNameRequest>& _msg);
+ static void GetSockNameResponse(const ::fidl::DecodedMessage<Control::GetSockNameResponse>& _msg);
+ static void GetPeerNameRequest(const ::fidl::DecodedMessage<Control::GetPeerNameRequest>& _msg);
+ static void GetPeerNameResponse(const ::fidl::DecodedMessage<Control::GetPeerNameResponse>& _msg);
+ static void SetSockOptRequest(const ::fidl::DecodedMessage<Control::SetSockOptRequest>& _msg);
+ static void SetSockOptResponse(const ::fidl::DecodedMessage<Control::SetSockOptResponse>& _msg);
+ static void GetSockOptRequest(const ::fidl::DecodedMessage<Control::GetSockOptRequest>& _msg);
+ static void GetSockOptResponse(const ::fidl::DecodedMessage<Control::GetSockOptResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketBindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketConnectResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetSockNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetSockNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetPeerNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetPeerNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketSetSockOptResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_BaseSocketGetSockOptResponseTable;
+
+// A network socket.
+//
+// Once a socket has been retrieved from a `Provider`, this interface is then used to further
+// configure and use the socket. This interface is essentially POSIX. Its implementation must
+// support Linux-specific arguments to {Get,Set}SockOpt.
+//
+// All methods on this type are nonblocking; their exact behaviors match their Linux counterparts.
+//
+// *Warning:* This protocol is not yet ready for direct use by clients. Instead, clients should
+// use the BSD sockets API to interact with sockets. We plan to change this protocol substantially
+// and clients that couple directly to this protocol will make those changes more difficult.
+class BaseSocket final {
+ BaseSocket() = delete;
+ public:
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct BindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketBindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct BindRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketBindRequestTable;
+ 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 = BindResponse;
+ };
+
+ struct ConnectResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketConnectResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ConnectRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketConnectRequestTable;
+ 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 = ConnectResponse;
+ };
+
+ struct GetSockNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketGetSockNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetSockNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetPeerNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketGetPeerNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetPeerNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetSockOptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketSetSockOptResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SetSockOptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t level;
+ int16_t optname;
+ ::fidl::VectorView<uint8_t> optval;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketSetSockOptRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 904;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 904;
+ 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 = SetSockOptResponse;
+ };
+
+ struct GetSockOptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketGetSockOptResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 920;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetSockOptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t level;
+ int16_t optname;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_BaseSocketGetSockOptRequestTable;
+ 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 = GetSockOptResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Bind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Connect_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 GetSockName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSockName_Impl(::zx::unowned_channel _client_end);
+ ~GetSockName_Impl() = default;
+ GetSockName_Impl(GetSockName_Impl&& other) = default;
+ GetSockName_Impl& operator=(GetSockName_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 GetPeerName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetPeerName_Impl(::zx::unowned_channel _client_end);
+ ~GetPeerName_Impl() = default;
+ GetPeerName_Impl(GetPeerName_Impl&& other) = default;
+ GetPeerName_Impl& operator=(GetPeerName_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 SetSockOpt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+ ~SetSockOpt_Impl() = default;
+ SetSockOpt_Impl(SetSockOpt_Impl&& other) = default;
+ SetSockOpt_Impl& operator=(SetSockOpt_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 GetSockOpt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname);
+ ~GetSockOpt_Impl() = default;
+ GetSockOpt_Impl(GetSockOpt_Impl&& other) = default;
+ GetSockOpt_Impl& operator=(GetSockOpt_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Bind = Bind_Impl<BindResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using GetSockName = GetSockName_Impl<GetSockNameResponse>;
+ using GetPeerName = GetPeerName_Impl<GetPeerNameResponse>;
+ using SetSockOpt = SetSockOpt_Impl<SetSockOptResponse>;
+ using GetSockOpt = GetSockOpt_Impl<GetSockOptResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Bind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Connect_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 GetSockName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSockName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetSockName_Impl() = default;
+ GetSockName_Impl(GetSockName_Impl&& other) = default;
+ GetSockName_Impl& operator=(GetSockName_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 GetPeerName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetPeerName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetPeerName_Impl() = default;
+ GetPeerName_Impl(GetPeerName_Impl&& other) = default;
+ GetPeerName_Impl& operator=(GetPeerName_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 SetSockOpt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+ ~SetSockOpt_Impl() = default;
+ SetSockOpt_Impl(SetSockOpt_Impl&& other) = default;
+ SetSockOpt_Impl& operator=(SetSockOpt_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 GetSockOpt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+ ~GetSockOpt_Impl() = default;
+ GetSockOpt_Impl(GetSockOpt_Impl&& other) = default;
+ GetSockOpt_Impl& operator=(GetSockOpt_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Bind = Bind_Impl<BindResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using GetSockName = GetSockName_Impl<GetSockNameResponse>;
+ using GetPeerName = GetPeerName_Impl<GetPeerNameResponse>;
+ using SetSockOpt = SetSockOpt_Impl<SetSockOptResponse>;
+ using GetSockOpt = GetSockOpt_Impl<GetSockOptResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sets the local address used for the socket.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Bind Bind(::fidl::VectorView<uint8_t> addr);
+
+ // Sets the local address used for the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Bind Bind(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Initiates a connection to a remote address.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Connect Connect(::fidl::VectorView<uint8_t> addr);
+
+ // Initiates a connection to a remote address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Connect Connect(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the local socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetSockName GetSockName();
+
+ // Retrieves the local socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSockName GetSockName(::fidl::BytePart _response_buffer);
+
+ // Retrieves the remote socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetPeerName GetPeerName();
+
+ // Retrieves the remote socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetPeerName GetPeerName(::fidl::BytePart _response_buffer);
+
+ // Sets the value of a socket option.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SetSockOpt SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+
+ // Sets the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetSockOpt SetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the value of a socket option.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetSockOpt GetSockOpt(int16_t level, int16_t optname);
+
+ // Retrieves the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSockOpt GetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sets the local address used for the socket.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+
+ // Sets the local address used for the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Initiates a connection to a remote address.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+
+ // Initiates a connection to a remote address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the local socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetSockName GetSockName(::zx::unowned_channel _client_end);
+
+ // Retrieves the local socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSockName GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the remote socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetPeerName GetPeerName(::zx::unowned_channel _client_end);
+
+ // Retrieves the remote socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetPeerName GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets the value of a socket option.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SetSockOpt SetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+
+ // Sets the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetSockOpt SetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the value of a socket option.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetSockOpt GetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname);
+
+ // Retrieves the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSockOpt GetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Sets the local address used for the socket.
+ static ::fidl::DecodeResult<BindResponse> Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer);
+
+ // Initiates a connection to a remote address.
+ static ::fidl::DecodeResult<ConnectResponse> Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieves the local socket address.
+ static ::fidl::DecodeResult<GetSockNameResponse> GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Retrieves the remote socket address.
+ static ::fidl::DecodeResult<GetPeerNameResponse> GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets the value of a socket option.
+ static ::fidl::DecodeResult<SetSockOptResponse> SetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSockOptRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieves the value of a socket option.
+ static ::fidl::DecodeResult<GetSockOptResponse> GetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSockOptRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = BaseSocket;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class BindCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<BindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BindCompleter = ::fidl::Completer<BindCompleterBase>;
+
+ virtual void Bind(::fidl::VectorView<uint8_t> addr, BindCompleter::Sync _completer) = 0;
+
+ class ConnectCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ConnectResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConnectCompleter = ::fidl::Completer<ConnectCompleterBase>;
+
+ virtual void Connect(::fidl::VectorView<uint8_t> addr, ConnectCompleter::Sync _completer) = 0;
+
+ class GetSockNameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> addr);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::DecodedMessage<GetSockNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSockNameCompleter = ::fidl::Completer<GetSockNameCompleterBase>;
+
+ virtual void GetSockName(GetSockNameCompleter::Sync _completer) = 0;
+
+ class GetPeerNameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> addr);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::DecodedMessage<GetPeerNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPeerNameCompleter = ::fidl::Completer<GetPeerNameCompleterBase>;
+
+ virtual void GetPeerName(GetPeerNameCompleter::Sync _completer) = 0;
+
+ class SetSockOptCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SetSockOptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetSockOptCompleter = ::fidl::Completer<SetSockOptCompleterBase>;
+
+ virtual void SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, SetSockOptCompleter::Sync _completer) = 0;
+
+ class GetSockOptCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> optval);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> optval);
+ void Reply(::fidl::DecodedMessage<GetSockOptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSockOptCompleter = ::fidl::Completer<GetSockOptCompleterBase>;
+
+ virtual void GetSockOpt(int16_t level, int16_t optname, GetSockOptCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<BaseSocket::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<BaseSocket::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<BaseSocket::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<BaseSocket::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<BaseSocket::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<BaseSocket::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<BaseSocket::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<BaseSocket::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<BaseSocket::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<BaseSocket::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<BaseSocket::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<BaseSocket::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<BaseSocket::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<BaseSocket::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<BaseSocket::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<BaseSocket::NodeSetFlagsResponse>& _msg);
+ static void BindRequest(const ::fidl::DecodedMessage<BaseSocket::BindRequest>& _msg);
+ static void BindResponse(const ::fidl::DecodedMessage<BaseSocket::BindResponse>& _msg);
+ static void ConnectRequest(const ::fidl::DecodedMessage<BaseSocket::ConnectRequest>& _msg);
+ static void ConnectResponse(const ::fidl::DecodedMessage<BaseSocket::ConnectResponse>& _msg);
+ static void GetSockNameRequest(const ::fidl::DecodedMessage<BaseSocket::GetSockNameRequest>& _msg);
+ static void GetSockNameResponse(const ::fidl::DecodedMessage<BaseSocket::GetSockNameResponse>& _msg);
+ static void GetPeerNameRequest(const ::fidl::DecodedMessage<BaseSocket::GetPeerNameRequest>& _msg);
+ static void GetPeerNameResponse(const ::fidl::DecodedMessage<BaseSocket::GetPeerNameResponse>& _msg);
+ static void SetSockOptRequest(const ::fidl::DecodedMessage<BaseSocket::SetSockOptRequest>& _msg);
+ static void SetSockOptResponse(const ::fidl::DecodedMessage<BaseSocket::SetSockOptResponse>& _msg);
+ static void GetSockOptRequest(const ::fidl::DecodedMessage<BaseSocket::GetSockOptRequest>& _msg);
+ static void GetSockOptResponse(const ::fidl::DecodedMessage<BaseSocket::GetSockOptResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketBindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketConnectResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetSockNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetSockNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetPeerNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetPeerNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketSetSockOptResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketGetSockOptResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketListenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketListenResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketAcceptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_StreamSocketAcceptResponseTable;
+
+// A stream socket.
+//
+// This type's [`fuchsia.io.Node/Describe`] method returns a socket which is used to transfer data
+// to and from the caller. Signals are used to communicate additional information about the state
+// of the socket such as connectedness and the presence of incoming connections in the case of a
+// listening socket.
+//
+// All methods on this type are nonblocking; their exact behaviors match their Linux counterparts.
+class StreamSocket final {
+ StreamSocket() = delete;
+ public:
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct BindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketBindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct BindRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketBindRequestTable;
+ 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 = BindResponse;
+ };
+
+ struct ConnectResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketConnectResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ConnectRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketConnectRequestTable;
+ 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 = ConnectResponse;
+ };
+
+ struct GetSockNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketGetSockNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetSockNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetPeerNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketGetPeerNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetPeerNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetSockOptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketSetSockOptResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SetSockOptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t level;
+ int16_t optname;
+ ::fidl::VectorView<uint8_t> optval;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketSetSockOptRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 904;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 904;
+ 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 = SetSockOptResponse;
+ };
+
+ struct GetSockOptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketGetSockOptResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 920;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetSockOptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t level;
+ int16_t optname;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketGetSockOptRequestTable;
+ 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 = GetSockOptResponse;
+ };
+
+ struct ListenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketListenResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ListenRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t backlog;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketListenRequestTable;
+ 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 = ListenResponse;
+ };
+
+ struct AcceptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketAcceptResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct AcceptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_StreamSocketAcceptRequestTable;
+ 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 = AcceptResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Bind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Connect_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 GetSockName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSockName_Impl(::zx::unowned_channel _client_end);
+ ~GetSockName_Impl() = default;
+ GetSockName_Impl(GetSockName_Impl&& other) = default;
+ GetSockName_Impl& operator=(GetSockName_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 GetPeerName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetPeerName_Impl(::zx::unowned_channel _client_end);
+ ~GetPeerName_Impl() = default;
+ GetPeerName_Impl(GetPeerName_Impl&& other) = default;
+ GetPeerName_Impl& operator=(GetPeerName_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 SetSockOpt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+ ~SetSockOpt_Impl() = default;
+ SetSockOpt_Impl(SetSockOpt_Impl&& other) = default;
+ SetSockOpt_Impl& operator=(SetSockOpt_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 GetSockOpt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname);
+ ~GetSockOpt_Impl() = default;
+ GetSockOpt_Impl(GetSockOpt_Impl&& other) = default;
+ GetSockOpt_Impl& operator=(GetSockOpt_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 Listen_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Listen_Impl(::zx::unowned_channel _client_end, int16_t backlog);
+ ~Listen_Impl() = default;
+ Listen_Impl(Listen_Impl&& other) = default;
+ Listen_Impl& operator=(Listen_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 Accept_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Accept_Impl(::zx::unowned_channel _client_end, int16_t flags);
+ ~Accept_Impl() = default;
+ Accept_Impl(Accept_Impl&& other) = default;
+ Accept_Impl& operator=(Accept_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Bind = Bind_Impl<BindResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using GetSockName = GetSockName_Impl<GetSockNameResponse>;
+ using GetPeerName = GetPeerName_Impl<GetPeerNameResponse>;
+ using SetSockOpt = SetSockOpt_Impl<SetSockOptResponse>;
+ using GetSockOpt = GetSockOpt_Impl<GetSockOptResponse>;
+ using Listen = Listen_Impl<ListenResponse>;
+ using Accept = Accept_Impl<AcceptResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Bind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Connect_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 GetSockName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSockName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetSockName_Impl() = default;
+ GetSockName_Impl(GetSockName_Impl&& other) = default;
+ GetSockName_Impl& operator=(GetSockName_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 GetPeerName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetPeerName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetPeerName_Impl() = default;
+ GetPeerName_Impl(GetPeerName_Impl&& other) = default;
+ GetPeerName_Impl& operator=(GetPeerName_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 SetSockOpt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+ ~SetSockOpt_Impl() = default;
+ SetSockOpt_Impl(SetSockOpt_Impl&& other) = default;
+ SetSockOpt_Impl& operator=(SetSockOpt_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 GetSockOpt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+ ~GetSockOpt_Impl() = default;
+ GetSockOpt_Impl(GetSockOpt_Impl&& other) = default;
+ GetSockOpt_Impl& operator=(GetSockOpt_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 Listen_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Listen_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer);
+ ~Listen_Impl() = default;
+ Listen_Impl(Listen_Impl&& other) = default;
+ Listen_Impl& operator=(Listen_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 Accept_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Accept_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer);
+ ~Accept_Impl() = default;
+ Accept_Impl(Accept_Impl&& other) = default;
+ Accept_Impl& operator=(Accept_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Bind = Bind_Impl<BindResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using GetSockName = GetSockName_Impl<GetSockNameResponse>;
+ using GetPeerName = GetPeerName_Impl<GetPeerNameResponse>;
+ using SetSockOpt = SetSockOpt_Impl<SetSockOptResponse>;
+ using GetSockOpt = GetSockOpt_Impl<GetSockOptResponse>;
+ using Listen = Listen_Impl<ListenResponse>;
+ using Accept = Accept_Impl<AcceptResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sets the local address used for the socket.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Bind Bind(::fidl::VectorView<uint8_t> addr);
+
+ // Sets the local address used for the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Bind Bind(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Initiates a connection to a remote address.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Connect Connect(::fidl::VectorView<uint8_t> addr);
+
+ // Initiates a connection to a remote address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Connect Connect(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the local socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetSockName GetSockName();
+
+ // Retrieves the local socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSockName GetSockName(::fidl::BytePart _response_buffer);
+
+ // Retrieves the remote socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetPeerName GetPeerName();
+
+ // Retrieves the remote socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetPeerName GetPeerName(::fidl::BytePart _response_buffer);
+
+ // Sets the value of a socket option.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SetSockOpt SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+
+ // Sets the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetSockOpt SetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the value of a socket option.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetSockOpt GetSockOpt(int16_t level, int16_t optname);
+
+ // Retrieves the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSockOpt GetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Listen Listen(int16_t backlog);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Listen Listen(::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer);
+
+ // Accepts a buffered incoming connection.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Accept Accept(int16_t flags);
+
+ // Accepts a buffered incoming connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Accept Accept(::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sets the local address used for the socket.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+
+ // Sets the local address used for the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Initiates a connection to a remote address.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+
+ // Initiates a connection to a remote address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the local socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetSockName GetSockName(::zx::unowned_channel _client_end);
+
+ // Retrieves the local socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSockName GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the remote socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetPeerName GetPeerName(::zx::unowned_channel _client_end);
+
+ // Retrieves the remote socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetPeerName GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets the value of a socket option.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SetSockOpt SetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+
+ // Sets the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetSockOpt SetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the value of a socket option.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetSockOpt GetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname);
+
+ // Retrieves the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSockOpt GetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Listen Listen(::zx::unowned_channel _client_end, int16_t backlog);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Listen Listen(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t backlog, ::fidl::BytePart _response_buffer);
+
+ // Accepts a buffered incoming connection.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Accept Accept(::zx::unowned_channel _client_end, int16_t flags);
+
+ // Accepts a buffered incoming connection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Accept Accept(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Sets the local address used for the socket.
+ static ::fidl::DecodeResult<BindResponse> Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer);
+
+ // Initiates a connection to a remote address.
+ static ::fidl::DecodeResult<ConnectResponse> Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieves the local socket address.
+ static ::fidl::DecodeResult<GetSockNameResponse> GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Retrieves the remote socket address.
+ static ::fidl::DecodeResult<GetPeerNameResponse> GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets the value of a socket option.
+ static ::fidl::DecodeResult<SetSockOptResponse> SetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSockOptRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieves the value of a socket option.
+ static ::fidl::DecodeResult<GetSockOptResponse> GetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSockOptRequest> params, ::fidl::BytePart response_buffer);
+
+ // Begins listening for new incoming connections. At most `backlog` connections will be
+ // buffered.
+ static ::fidl::DecodeResult<ListenResponse> Listen(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ListenRequest> params, ::fidl::BytePart response_buffer);
+
+ // Accepts a buffered incoming connection.
+ static ::fidl::DecodeResult<AcceptResponse> Accept(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AcceptRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = StreamSocket;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class BindCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<BindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BindCompleter = ::fidl::Completer<BindCompleterBase>;
+
+ virtual void Bind(::fidl::VectorView<uint8_t> addr, BindCompleter::Sync _completer) = 0;
+
+ class ConnectCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ConnectResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConnectCompleter = ::fidl::Completer<ConnectCompleterBase>;
+
+ virtual void Connect(::fidl::VectorView<uint8_t> addr, ConnectCompleter::Sync _completer) = 0;
+
+ class GetSockNameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> addr);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::DecodedMessage<GetSockNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSockNameCompleter = ::fidl::Completer<GetSockNameCompleterBase>;
+
+ virtual void GetSockName(GetSockNameCompleter::Sync _completer) = 0;
+
+ class GetPeerNameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> addr);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::DecodedMessage<GetPeerNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPeerNameCompleter = ::fidl::Completer<GetPeerNameCompleterBase>;
+
+ virtual void GetPeerName(GetPeerNameCompleter::Sync _completer) = 0;
+
+ class SetSockOptCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SetSockOptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetSockOptCompleter = ::fidl::Completer<SetSockOptCompleterBase>;
+
+ virtual void SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, SetSockOptCompleter::Sync _completer) = 0;
+
+ class GetSockOptCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> optval);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> optval);
+ void Reply(::fidl::DecodedMessage<GetSockOptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSockOptCompleter = ::fidl::Completer<GetSockOptCompleterBase>;
+
+ virtual void GetSockOpt(int16_t level, int16_t optname, GetSockOptCompleter::Sync _completer) = 0;
+
+ class ListenCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ListenResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ListenCompleter = ::fidl::Completer<ListenCompleterBase>;
+
+ virtual void Listen(int16_t backlog, ListenCompleter::Sync _completer) = 0;
+
+ class AcceptCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Result result);
+ void ReplySuccess(::zx::channel s);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::zx::channel s);
+ void Reply(::fidl::DecodedMessage<AcceptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AcceptCompleter = ::fidl::Completer<AcceptCompleterBase>;
+
+ virtual void Accept(int16_t flags, AcceptCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<StreamSocket::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<StreamSocket::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<StreamSocket::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<StreamSocket::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<StreamSocket::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<StreamSocket::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<StreamSocket::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<StreamSocket::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<StreamSocket::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<StreamSocket::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<StreamSocket::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<StreamSocket::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<StreamSocket::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<StreamSocket::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<StreamSocket::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<StreamSocket::NodeSetFlagsResponse>& _msg);
+ static void BindRequest(const ::fidl::DecodedMessage<StreamSocket::BindRequest>& _msg);
+ static void BindResponse(const ::fidl::DecodedMessage<StreamSocket::BindResponse>& _msg);
+ static void ConnectRequest(const ::fidl::DecodedMessage<StreamSocket::ConnectRequest>& _msg);
+ static void ConnectResponse(const ::fidl::DecodedMessage<StreamSocket::ConnectResponse>& _msg);
+ static void GetSockNameRequest(const ::fidl::DecodedMessage<StreamSocket::GetSockNameRequest>& _msg);
+ static void GetSockNameResponse(const ::fidl::DecodedMessage<StreamSocket::GetSockNameResponse>& _msg);
+ static void GetPeerNameRequest(const ::fidl::DecodedMessage<StreamSocket::GetPeerNameRequest>& _msg);
+ static void GetPeerNameResponse(const ::fidl::DecodedMessage<StreamSocket::GetPeerNameResponse>& _msg);
+ static void SetSockOptRequest(const ::fidl::DecodedMessage<StreamSocket::SetSockOptRequest>& _msg);
+ static void SetSockOptResponse(const ::fidl::DecodedMessage<StreamSocket::SetSockOptResponse>& _msg);
+ static void GetSockOptRequest(const ::fidl::DecodedMessage<StreamSocket::GetSockOptRequest>& _msg);
+ static void GetSockOptResponse(const ::fidl::DecodedMessage<StreamSocket::GetSockOptResponse>& _msg);
+ static void ListenRequest(const ::fidl::DecodedMessage<StreamSocket::ListenRequest>& _msg);
+ static void ListenResponse(const ::fidl::DecodedMessage<StreamSocket::ListenResponse>& _msg);
+ static void AcceptRequest(const ::fidl::DecodedMessage<StreamSocket::AcceptRequest>& _msg);
+ static void AcceptResponse(const ::fidl::DecodedMessage<StreamSocket::AcceptResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketCloneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketCloneResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketCloseResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketDescribeRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketDescribeResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketOnOpenRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketOnOpenEventTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSetAttrRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSetAttrResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketNodeGetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketNodeGetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketNodeSetFlagsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketNodeSetFlagsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketBindRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketBindResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketConnectResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetSockNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetSockNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetPeerNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetPeerNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSetSockOptResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetSockOptRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketGetSockOptResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketShutdownRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketShutdownResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketRecvMsgRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketRecvMsgResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSendMsgRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_posix_socket_DatagramSocketSendMsgResponseTable;
+
+// A datagram socket.
+//
+// This type's [`fuchsia.io.Node/Describe`] method returns an eventpair which is used to signal
+// additional information about the state of the socket such as readiness or shutdown-ness.
+//
+// All methods on this type are nonblocking; their exact behaviors match their Linux counterparts.
+class DatagramSocket final {
+ DatagramSocket() = delete;
+ public:
+
+ struct CloneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::zx::channel object;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketCloneRequestTable;
+ 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;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketCloseResponseTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+ struct DescribeResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketDescribeResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using DescribeRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnOpenResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketOnOpenEventTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 24;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SyncResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketSyncResponseTable;
+ 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 SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketGetAttrResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ 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 GetAttrRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetAttrResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketSetAttrResponseTable;
+ 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 SetAttrRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+ ::llcpp::fuchsia::io::NodeAttributes attributes;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketSetAttrRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 80;
+ 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 = SetAttrResponse;
+ };
+
+ struct NodeGetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketNodeGetFlagsResponseTable;
+ 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 NodeGetFlagsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct NodeSetFlagsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketNodeSetFlagsResponseTable;
+ 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 NodeSetFlagsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketNodeSetFlagsRequestTable;
+ 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 = NodeSetFlagsResponse;
+ };
+
+ struct BindResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketBindResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct BindRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketBindRequestTable;
+ 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 = BindResponse;
+ };
+
+ struct ConnectResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketConnectResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ConnectRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketConnectRequestTable;
+ 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 = ConnectResponse;
+ };
+
+ struct GetSockNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketGetSockNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetSockNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetPeerNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketGetPeerNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetPeerNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetSockOptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketSetSockOptResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SetSockOptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t level;
+ int16_t optname;
+ ::fidl::VectorView<uint8_t> optval;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketSetSockOptRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 904;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 904;
+ 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 = SetSockOptResponse;
+ };
+
+ struct GetSockOptResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketGetSockOptResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 920;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct GetSockOptRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t level;
+ int16_t optname;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketGetSockOptRequestTable;
+ 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 = GetSockOptResponse;
+ };
+
+ struct ShutdownResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketShutdownResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct ShutdownRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int16_t how;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketShutdownRequestTable;
+ 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 = ShutdownResponse;
+ };
+
+ struct RecvMsgResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketRecvMsgResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct RecvMsgRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t addr_len;
+ uint32_t data_len;
+ uint32_t control_len;
+ int16_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketRecvMsgRequestTable;
+ 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 = RecvMsgResponse;
+ };
+
+ struct SendMsgResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketSendMsgResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SendMsgRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<uint8_t> addr;
+ ::fidl::VectorView<::fidl::VectorView<uint8_t>> data;
+ ::fidl::VectorView<uint8_t> control;
+ int16_t flags;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_posix_socket_DatagramSocketSendMsgRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 72;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 72;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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 = SendMsgResponse;
+ };
+
+
+ struct EventHandlers {
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ fit::callback<zx_status_t(int32_t s, ::llcpp::fuchsia::io::NodeInfo info)> on_open;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, uint32_t flags);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Bind_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Connect_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 GetSockName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSockName_Impl(::zx::unowned_channel _client_end);
+ ~GetSockName_Impl() = default;
+ GetSockName_Impl(GetSockName_Impl&& other) = default;
+ GetSockName_Impl& operator=(GetSockName_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 GetPeerName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetPeerName_Impl(::zx::unowned_channel _client_end);
+ ~GetPeerName_Impl() = default;
+ GetPeerName_Impl(GetPeerName_Impl&& other) = default;
+ GetPeerName_Impl& operator=(GetPeerName_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 SetSockOpt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+ ~SetSockOpt_Impl() = default;
+ SetSockOpt_Impl(SetSockOpt_Impl&& other) = default;
+ SetSockOpt_Impl& operator=(SetSockOpt_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 GetSockOpt_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetSockOpt_Impl(::zx::unowned_channel _client_end, int16_t level, int16_t optname);
+ ~GetSockOpt_Impl() = default;
+ GetSockOpt_Impl(GetSockOpt_Impl&& other) = default;
+ GetSockOpt_Impl& operator=(GetSockOpt_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 Shutdown_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Shutdown_Impl(::zx::unowned_channel _client_end, int16_t how);
+ ~Shutdown_Impl() = default;
+ Shutdown_Impl(Shutdown_Impl&& other) = default;
+ Shutdown_Impl& operator=(Shutdown_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 RecvMsg_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ RecvMsg_Impl(::zx::unowned_channel _client_end, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags);
+ ~RecvMsg_Impl() = default;
+ RecvMsg_Impl(RecvMsg_Impl&& other) = default;
+ RecvMsg_Impl& operator=(RecvMsg_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 SendMsg_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SendMsg_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags);
+ ~SendMsg_Impl() = default;
+ SendMsg_Impl(SendMsg_Impl&& other) = default;
+ SendMsg_Impl& operator=(SendMsg_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Bind = Bind_Impl<BindResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using GetSockName = GetSockName_Impl<GetSockNameResponse>;
+ using GetPeerName = GetPeerName_Impl<GetPeerNameResponse>;
+ using SetSockOpt = SetSockOpt_Impl<SetSockOptResponse>;
+ using GetSockOpt = GetSockOpt_Impl<GetSockOptResponse>;
+ using Shutdown = Shutdown_Impl<ShutdownResponse>;
+ using RecvMsg = RecvMsg_Impl<RecvMsgResponse>;
+ using SendMsg = SendMsg_Impl<SendMsgResponse>;
+ };
+
+ // 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:
+ class Clone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Clone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+ ~Clone_Impl() = default;
+ Clone_Impl(Clone_Impl&& other) = default;
+ Clone_Impl& operator=(Clone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Describe_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Describe_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Describe_Impl() = default;
+ Describe_Impl(Describe_Impl&& other) = default;
+ Describe_Impl& operator=(Describe_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 Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_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 GetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetAttr_Impl() = default;
+ GetAttr_Impl(GetAttr_Impl&& other) = default;
+ GetAttr_Impl& operator=(GetAttr_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 SetAttr_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetAttr_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+ ~SetAttr_Impl() = default;
+ SetAttr_Impl(SetAttr_Impl&& other) = default;
+ SetAttr_Impl& operator=(SetAttr_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 NodeGetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeGetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~NodeGetFlags_Impl() = default;
+ NodeGetFlags_Impl(NodeGetFlags_Impl&& other) = default;
+ NodeGetFlags_Impl& operator=(NodeGetFlags_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 NodeSetFlags_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ NodeSetFlags_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+ ~NodeSetFlags_Impl() = default;
+ NodeSetFlags_Impl(NodeSetFlags_Impl&& other) = default;
+ NodeSetFlags_Impl& operator=(NodeSetFlags_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 Bind_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Bind_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+ ~Bind_Impl() = default;
+ Bind_Impl(Bind_Impl&& other) = default;
+ Bind_Impl& operator=(Bind_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 Connect_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_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 GetSockName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSockName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetSockName_Impl() = default;
+ GetSockName_Impl(GetSockName_Impl&& other) = default;
+ GetSockName_Impl& operator=(GetSockName_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 GetPeerName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetPeerName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetPeerName_Impl() = default;
+ GetPeerName_Impl(GetPeerName_Impl&& other) = default;
+ GetPeerName_Impl& operator=(GetPeerName_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 SetSockOpt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+ ~SetSockOpt_Impl() = default;
+ SetSockOpt_Impl(SetSockOpt_Impl&& other) = default;
+ SetSockOpt_Impl& operator=(SetSockOpt_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 GetSockOpt_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetSockOpt_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+ ~GetSockOpt_Impl() = default;
+ GetSockOpt_Impl(GetSockOpt_Impl&& other) = default;
+ GetSockOpt_Impl& operator=(GetSockOpt_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 Shutdown_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Shutdown_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t how, ::fidl::BytePart _response_buffer);
+ ~Shutdown_Impl() = default;
+ Shutdown_Impl(Shutdown_Impl&& other) = default;
+ Shutdown_Impl& operator=(Shutdown_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 RecvMsg_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ RecvMsg_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags, ::fidl::BytePart _response_buffer);
+ ~RecvMsg_Impl() = default;
+ RecvMsg_Impl(RecvMsg_Impl&& other) = default;
+ RecvMsg_Impl& operator=(RecvMsg_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 SendMsg_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SendMsg_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags, ::fidl::BytePart _response_buffer);
+ ~SendMsg_Impl() = default;
+ SendMsg_Impl(SendMsg_Impl&& other) = default;
+ SendMsg_Impl& operator=(SendMsg_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 Clone = Clone_Impl;
+ using Close = Close_Impl<CloseResponse>;
+ using Describe = Describe_Impl<DescribeResponse>;
+ using Sync = Sync_Impl<SyncResponse>;
+ using GetAttr = GetAttr_Impl<GetAttrResponse>;
+ using SetAttr = SetAttr_Impl<SetAttrResponse>;
+ using NodeGetFlags = NodeGetFlags_Impl<NodeGetFlagsResponse>;
+ using NodeSetFlags = NodeSetFlags_Impl<NodeSetFlagsResponse>;
+ using Bind = Bind_Impl<BindResponse>;
+ using Connect = Connect_Impl<ConnectResponse>;
+ using GetSockName = GetSockName_Impl<GetSockNameResponse>;
+ using GetPeerName = GetPeerName_Impl<GetPeerNameResponse>;
+ using SetSockOpt = SetSockOpt_Impl<SetSockOptResponse>;
+ using GetSockOpt = GetSockOpt_Impl<GetSockOptResponse>;
+ using Shutdown = Shutdown_Impl<ShutdownResponse>;
+ using RecvMsg = RecvMsg_Impl<RecvMsgResponse>;
+ using SendMsg = SendMsg_Impl<SendMsgResponse>;
+ };
+
+ 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_; }
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Clone Clone(uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Clone Clone(::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Describe Describe();
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Describe Describe(::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Sync Sync(::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetAttr GetAttr();
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetAttr GetAttr(::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetAttr SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetAttr SetAttr(::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeGetFlags NodeGetFlags();
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeGetFlags NodeGetFlags(::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NodeSetFlags NodeSetFlags(uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::NodeSetFlags NodeSetFlags(::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sets the local address used for the socket.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Bind Bind(::fidl::VectorView<uint8_t> addr);
+
+ // Sets the local address used for the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Bind Bind(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Initiates a connection to a remote address.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Connect Connect(::fidl::VectorView<uint8_t> addr);
+
+ // Initiates a connection to a remote address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Connect Connect(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the local socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetSockName GetSockName();
+
+ // Retrieves the local socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSockName GetSockName(::fidl::BytePart _response_buffer);
+
+ // Retrieves the remote socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetPeerName GetPeerName();
+
+ // Retrieves the remote socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetPeerName GetPeerName(::fidl::BytePart _response_buffer);
+
+ // Sets the value of a socket option.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SetSockOpt SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+
+ // Sets the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetSockOpt SetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the value of a socket option.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetSockOpt GetSockOpt(int16_t level, int16_t optname);
+
+ // Retrieves the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetSockOpt GetSockOpt(::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+
+ // Shuts down part of the socket.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Shutdown Shutdown(int16_t how);
+
+ // Shuts down part of the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Shutdown Shutdown(::fidl::BytePart _request_buffer, int16_t how, ::fidl::BytePart _response_buffer);
+
+ // Receives a message from the socket.
+ // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::RecvMsg RecvMsg(uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags);
+
+ // Receives a message from the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RecvMsg RecvMsg(::fidl::BytePart _request_buffer, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sends a message on the socket.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SendMsg SendMsg(::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags);
+
+ // Sends a message on the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SendMsg SendMsg(::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Clone Clone(::zx::unowned_channel _client_end, uint32_t flags, ::zx::channel object);
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Clone Clone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::zx::channel object);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Allocates 80 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Describe Describe(::zx::unowned_channel _client_end);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Describe Describe(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Sync Sync(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetAttr GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Allocates 104 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetAttr SetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, ::fidl::BytePart _response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeGetFlags NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, uint32_t flags);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::NodeSetFlags NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sets the local address used for the socket.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+
+ // Sets the local address used for the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Bind Bind(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Initiates a connection to a remote address.
+ // Allocates 208 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr);
+
+ // Initiates a connection to a remote address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the local socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetSockName GetSockName(::zx::unowned_channel _client_end);
+
+ // Retrieves the local socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSockName GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the remote socket address.
+ // Allocates 200 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetPeerName GetPeerName(::zx::unowned_channel _client_end);
+
+ // Retrieves the remote socket address.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetPeerName GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Sets the value of a socket option.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SetSockOpt SetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval);
+
+ // Sets the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetSockOpt SetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, ::fidl::BytePart _response_buffer);
+
+ // Retrieves the value of a socket option.
+ // Allocates 24 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetSockOpt GetSockOpt(::zx::unowned_channel _client_end, int16_t level, int16_t optname);
+
+ // Retrieves the value of a socket option.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetSockOpt GetSockOpt(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t level, int16_t optname, ::fidl::BytePart _response_buffer);
+
+ // Shuts down part of the socket.
+ // Allocates 72 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Shutdown Shutdown(::zx::unowned_channel _client_end, int16_t how);
+
+ // Shuts down part of the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Shutdown Shutdown(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int16_t how, ::fidl::BytePart _response_buffer);
+
+ // Receives a message from the socket.
+ // Allocates 32 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::RecvMsg RecvMsg(::zx::unowned_channel _client_end, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags);
+
+ // Receives a message from the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RecvMsg RecvMsg(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags, ::fidl::BytePart _response_buffer);
+
+ // Sends a message on the socket.
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SendMsg SendMsg(::zx::unowned_channel _client_end, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags);
+
+ // Sends a message on the socket.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SendMsg SendMsg(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags, ::fidl::BytePart _response_buffer);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Create another connection to the same remote object.
+ //
+ // `flags` may be any of:
+ //
+ // - `OPEN_RIGHT_*`
+ // - `OPEN_FLAG_APPEND`
+ // - `OPEN_FLAG_NO_REMOTE`
+ // - `OPEN_FLAG_DESCRIBE`
+ // - `CLONE_FLAG_SAME_RIGHTS`
+ //
+ // All other flags are ignored.
+ //
+ // The `OPEN_RIGHT_*` bits in `flags` request corresponding rights over the resulting
+ // cloned object.
+ // The cloned object must have rights less than or equal to the original object.
+ // Alternatively, pass `CLONE_FLAG_SAME_RIGHTS` to inherit the rights on the source connection.
+ // It is invalid to pass any of the `OPEN_RIGHT_*` flags together with
+ // `CLONE_FLAG_SAME_RIGHTS`.
+ static ::fidl::internal::StatusAndError Clone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloneRequest> params);
+
+ // Terminates connection with object.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<CloseResponse> Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Returns extra information about the type of the object.
+ // If the `Describe` operation fails, the connection is closed.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<DescribeResponse> Describe(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Synchronizes updates to the node to the underlying media, if it exists.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Acquires information about the node.
+ //
+ // This method does not require any rights.
+ static ::fidl::DecodeResult<GetAttrResponse> GetAttr(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Updates information about the node.
+ // `flags` may be any of `NODE_ATTRIBUTE_FLAG_*`.
+ //
+ // This method requires following rights: `OPEN_RIGHT_WRITABLE`.
+ static ::fidl::DecodeResult<SetAttrResponse> SetAttr(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetAttrRequest> params, ::fidl::BytePart response_buffer);
+
+ // Acquires the `Directory.Open` rights and flags used to access this file.
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as GetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeGetFlagsResponse> NodeGetFlags(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Changes the `Directory.Open` flags used to access the file.
+ // Supported flags which can be turned on / off:
+ // - `OPEN_FLAG_APPEND`
+ //
+ // This method does not require any rights.
+ // This method has the same functionality as SetFlags for File and is
+ // meant as an in-progress replacement.
+ static ::fidl::DecodeResult<NodeSetFlagsResponse> NodeSetFlags(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<NodeSetFlagsRequest> params, ::fidl::BytePart response_buffer);
+
+ // Sets the local address used for the socket.
+ static ::fidl::DecodeResult<BindResponse> Bind(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindRequest> params, ::fidl::BytePart response_buffer);
+
+ // Initiates a connection to a remote address.
+ static ::fidl::DecodeResult<ConnectResponse> Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieves the local socket address.
+ static ::fidl::DecodeResult<GetSockNameResponse> GetSockName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Retrieves the remote socket address.
+ static ::fidl::DecodeResult<GetPeerNameResponse> GetPeerName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Sets the value of a socket option.
+ static ::fidl::DecodeResult<SetSockOptResponse> SetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetSockOptRequest> params, ::fidl::BytePart response_buffer);
+
+ // Retrieves the value of a socket option.
+ static ::fidl::DecodeResult<GetSockOptResponse> GetSockOpt(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<GetSockOptRequest> params, ::fidl::BytePart response_buffer);
+
+ // Shuts down part of the socket.
+ static ::fidl::DecodeResult<ShutdownResponse> Shutdown(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ShutdownRequest> params, ::fidl::BytePart response_buffer);
+
+ // Receives a message from the socket.
+ static ::fidl::DecodeResult<RecvMsgResponse> RecvMsg(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RecvMsgRequest> params, ::fidl::BytePart response_buffer);
+
+ // Sends a message on the socket.
+ static ::fidl::DecodeResult<SendMsgResponse> SendMsg(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SendMsgRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DatagramSocket;
+ using _Base = ::fidl::CompleterBase;
+
+ using CloneCompleter = ::fidl::Completer<>;
+
+ virtual void Clone(uint32_t flags, ::zx::channel object, CloneCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::Sync _completer) = 0;
+
+ class DescribeCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::io::NodeInfo info);
+ void Reply(::fidl::DecodedMessage<DescribeResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DescribeCompleter = ::fidl::Completer<DescribeCompleterBase>;
+
+ virtual void Describe(DescribeCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SyncResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ class GetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeAttributes attributes);
+ void Reply(::fidl::DecodedMessage<GetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetAttrCompleter = ::fidl::Completer<GetAttrCompleterBase>;
+
+ virtual void GetAttr(GetAttrCompleter::Sync _completer) = 0;
+
+ class SetAttrCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<SetAttrResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetAttrCompleter = ::fidl::Completer<SetAttrCompleterBase>;
+
+ virtual void SetAttr(uint32_t flags, ::llcpp::fuchsia::io::NodeAttributes attributes, SetAttrCompleter::Sync _completer) = 0;
+
+ class NodeGetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint32_t flags);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint32_t flags);
+ void Reply(::fidl::DecodedMessage<NodeGetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeGetFlagsCompleter = ::fidl::Completer<NodeGetFlagsCompleterBase>;
+
+ virtual void NodeGetFlags(NodeGetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class NodeSetFlagsCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s);
+ void Reply(::fidl::BytePart _buffer, int32_t s);
+ void Reply(::fidl::DecodedMessage<NodeSetFlagsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using NodeSetFlagsCompleter = ::fidl::Completer<NodeSetFlagsCompleterBase>;
+
+ virtual void NodeSetFlags(uint32_t flags, NodeSetFlagsCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class BindCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<BindResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using BindCompleter = ::fidl::Completer<BindCompleterBase>;
+
+ virtual void Bind(::fidl::VectorView<uint8_t> addr, BindCompleter::Sync _completer) = 0;
+
+ class ConnectCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ConnectResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConnectCompleter = ::fidl::Completer<ConnectCompleterBase>;
+
+ virtual void Connect(::fidl::VectorView<uint8_t> addr, ConnectCompleter::Sync _completer) = 0;
+
+ class GetSockNameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> addr);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::DecodedMessage<GetSockNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSockNameCompleter = ::fidl::Completer<GetSockNameCompleterBase>;
+
+ virtual void GetSockName(GetSockNameCompleter::Sync _completer) = 0;
+
+ class GetPeerNameCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> addr);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr);
+ void Reply(::fidl::DecodedMessage<GetPeerNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPeerNameCompleter = ::fidl::Completer<GetPeerNameCompleterBase>;
+
+ virtual void GetPeerName(GetPeerNameCompleter::Sync _completer) = 0;
+
+ class SetSockOptCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SetSockOptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetSockOptCompleter = ::fidl::Completer<SetSockOptCompleterBase>;
+
+ virtual void SetSockOpt(int16_t level, int16_t optname, ::fidl::VectorView<uint8_t> optval, SetSockOptCompleter::Sync _completer) = 0;
+
+ class GetSockOptCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> optval);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> optval);
+ void Reply(::fidl::DecodedMessage<GetSockOptResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetSockOptCompleter = ::fidl::Completer<GetSockOptCompleterBase>;
+
+ virtual void GetSockOpt(int16_t level, int16_t optname, GetSockOptCompleter::Sync _completer) = 0;
+
+ class ShutdownCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<ShutdownResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ShutdownCompleter = ::fidl::Completer<ShutdownCompleterBase>;
+
+ virtual void Shutdown(int16_t how, ShutdownCompleter::Sync _completer) = 0;
+
+ class RecvMsgCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Result result);
+ void ReplySuccess(::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<uint8_t> data, ::fidl::VectorView<uint8_t> control, uint32_t truncated);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<uint8_t> data, ::fidl::VectorView<uint8_t> control, uint32_t truncated);
+ void Reply(::fidl::DecodedMessage<RecvMsgResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using RecvMsgCompleter = ::fidl::Completer<RecvMsgCompleterBase>;
+
+ virtual void RecvMsg(uint32_t addr_len, uint32_t data_len, uint32_t control_len, int16_t flags, RecvMsgCompleter::Sync _completer) = 0;
+
+ class SendMsgCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Result result);
+ void ReplySuccess(int64_t len);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, int64_t len);
+ void Reply(::fidl::DecodedMessage<SendMsgResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SendMsgCompleter = ::fidl::Completer<SendMsgCompleterBase>;
+
+ virtual void SendMsg(::fidl::VectorView<uint8_t> addr, ::fidl::VectorView<::fidl::VectorView<uint8_t>> data, ::fidl::VectorView<uint8_t> control, int16_t flags, SendMsgCompleter::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);
+ }
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, int32_t s, ::llcpp::fuchsia::io::NodeInfo info);
+
+ // An event produced eagerly by a FIDL server if requested by `OPEN_FLAG_DESCRIBE`.
+ //
+ // Indicates the success or failure of the open operation, and optionally describes the
+ // object. If the status is `ZX_OK`, `info` contains descriptive information about the object
+ // (the same as would be returned by `Describe`).
+ // Messages are encoded in-place.
+ static zx_status_t SendOnOpenEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnOpenResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CloneRequest(const ::fidl::DecodedMessage<DatagramSocket::CloneRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<DatagramSocket::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<DatagramSocket::CloseResponse>& _msg);
+ static void DescribeRequest(const ::fidl::DecodedMessage<DatagramSocket::DescribeRequest>& _msg);
+ static void DescribeResponse(const ::fidl::DecodedMessage<DatagramSocket::DescribeResponse>& _msg);
+ static void OnOpenResponse(const ::fidl::DecodedMessage<DatagramSocket::OnOpenResponse>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<DatagramSocket::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<DatagramSocket::SyncResponse>& _msg);
+ static void GetAttrRequest(const ::fidl::DecodedMessage<DatagramSocket::GetAttrRequest>& _msg);
+ static void GetAttrResponse(const ::fidl::DecodedMessage<DatagramSocket::GetAttrResponse>& _msg);
+ static void SetAttrRequest(const ::fidl::DecodedMessage<DatagramSocket::SetAttrRequest>& _msg);
+ static void SetAttrResponse(const ::fidl::DecodedMessage<DatagramSocket::SetAttrResponse>& _msg);
+ static void NodeGetFlagsRequest(const ::fidl::DecodedMessage<DatagramSocket::NodeGetFlagsRequest>& _msg);
+ static void NodeGetFlagsResponse(const ::fidl::DecodedMessage<DatagramSocket::NodeGetFlagsResponse>& _msg);
+ static void NodeSetFlagsRequest(const ::fidl::DecodedMessage<DatagramSocket::NodeSetFlagsRequest>& _msg);
+ static void NodeSetFlagsResponse(const ::fidl::DecodedMessage<DatagramSocket::NodeSetFlagsResponse>& _msg);
+ static void BindRequest(const ::fidl::DecodedMessage<DatagramSocket::BindRequest>& _msg);
+ static void BindResponse(const ::fidl::DecodedMessage<DatagramSocket::BindResponse>& _msg);
+ static void ConnectRequest(const ::fidl::DecodedMessage<DatagramSocket::ConnectRequest>& _msg);
+ static void ConnectResponse(const ::fidl::DecodedMessage<DatagramSocket::ConnectResponse>& _msg);
+ static void GetSockNameRequest(const ::fidl::DecodedMessage<DatagramSocket::GetSockNameRequest>& _msg);
+ static void GetSockNameResponse(const ::fidl::DecodedMessage<DatagramSocket::GetSockNameResponse>& _msg);
+ static void GetPeerNameRequest(const ::fidl::DecodedMessage<DatagramSocket::GetPeerNameRequest>& _msg);
+ static void GetPeerNameResponse(const ::fidl::DecodedMessage<DatagramSocket::GetPeerNameResponse>& _msg);
+ static void SetSockOptRequest(const ::fidl::DecodedMessage<DatagramSocket::SetSockOptRequest>& _msg);
+ static void SetSockOptResponse(const ::fidl::DecodedMessage<DatagramSocket::SetSockOptResponse>& _msg);
+ static void GetSockOptRequest(const ::fidl::DecodedMessage<DatagramSocket::GetSockOptRequest>& _msg);
+ static void GetSockOptResponse(const ::fidl::DecodedMessage<DatagramSocket::GetSockOptResponse>& _msg);
+ static void ShutdownRequest(const ::fidl::DecodedMessage<DatagramSocket::ShutdownRequest>& _msg);
+ static void ShutdownResponse(const ::fidl::DecodedMessage<DatagramSocket::ShutdownResponse>& _msg);
+ static void RecvMsgRequest(const ::fidl::DecodedMessage<DatagramSocket::RecvMsgRequest>& _msg);
+ static void RecvMsgResponse(const ::fidl::DecodedMessage<DatagramSocket::RecvMsgResponse>& _msg);
+ static void SendMsgRequest(const ::fidl::DecodedMessage<DatagramSocket::SendMsgRequest>& _msg);
+ static void SendMsgResponse(const ::fidl::DecodedMessage<DatagramSocket::SendMsgResponse>& _msg);
+ };
+};
+
+} // namespace socket
+} // namespace posix
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response, optval) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response) == ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockOpt_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response, addr) == 0);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response, data) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response, control) == 32);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response, truncated) == 48);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response) == ::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::DatagramSocket_RecvMsg_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response, addr) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response) == ::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_GetSockName_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response, addr) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response) == ::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_GetPeerName_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response) == ::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::StreamSocket_Listen_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response, s) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response) == ::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::StreamSocket_Accept_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Provider_Socket2_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::Provider_Socket2_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider_Socket2_Response, s) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Provider_Socket2_Response) == ::llcpp::fuchsia::posix::socket::Provider_Socket2_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Provider_Socket2_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::Provider_Socket2_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Provider::SocketRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Provider::SocketRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Provider::SocketRequest)
+ == ::llcpp::fuchsia::posix::socket::Provider::SocketRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::SocketRequest, domain) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::SocketRequest, type) == 18);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::SocketRequest, protocol) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Provider::SocketResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Provider::SocketResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Provider::SocketResponse)
+ == ::llcpp::fuchsia::posix::socket::Provider::SocketResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::SocketResponse, code) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::SocketResponse, s) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Provider::Socket2Request> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Provider::Socket2Request> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Provider::Socket2Request)
+ == ::llcpp::fuchsia::posix::socket::Provider::Socket2Request::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::Socket2Request, domain) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::Socket2Request, type) == 18);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::Socket2Request, protocol) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Provider::Socket2Response> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Provider::Socket2Response> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Provider::Socket2Response)
+ == ::llcpp::fuchsia::posix::socket::Provider::Socket2Response::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Provider::Socket2Response, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response) == ::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::DatagramSocket_Shutdown_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response, len) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response) == ::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::DatagramSocket_SendMsg_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response) == ::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_SetSockOpt_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response) == ::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_Connect_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response>);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response) == ::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::posix::socket::BaseSocket_Bind_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::CloneRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::CloseResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::DescribeResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::OnOpenResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::SyncResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::GetAttrResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::SetAttrRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::SetAttrResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::BindRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::BindRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::BindRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::BindRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::BindRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::BindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::BindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::BindResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::BindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::BindResponse, code) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::ConnectRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::ConnectRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::ConnectRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::ConnectRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::ConnectRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::ConnectResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::ConnectResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::ConnectResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::ConnectResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::ConnectResponse, code) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::ListenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::ListenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::ListenRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::ListenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::ListenRequest, backlog) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::ListenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::ListenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::ListenResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::ListenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::ListenResponse, code) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::AcceptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::AcceptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::AcceptRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::AcceptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::AcceptRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::AcceptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::AcceptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::AcceptResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::AcceptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::AcceptResponse, code) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::AcceptResponse, s) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::GetSockNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::GetSockNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::GetSockNameResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::GetSockNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetSockNameResponse, code) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetSockNameResponse, addr) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::GetPeerNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::GetPeerNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::GetPeerNameResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::GetPeerNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetPeerNameResponse, code) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetPeerNameResponse, addr) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::SetSockOptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::SetSockOptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::SetSockOptRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::SetSockOptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::SetSockOptRequest, level) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::SetSockOptRequest, optname) == 18);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::SetSockOptRequest, optval) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::SetSockOptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::SetSockOptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::SetSockOptResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::SetSockOptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::SetSockOptResponse, code) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::GetSockOptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::GetSockOptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::GetSockOptRequest)
+ == ::llcpp::fuchsia::posix::socket::Control::GetSockOptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetSockOptRequest, level) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetSockOptRequest, optname) == 18);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::Control::GetSockOptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::Control::GetSockOptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::Control::GetSockOptResponse)
+ == ::llcpp::fuchsia::posix::socket::Control::GetSockOptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetSockOptResponse, code) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::Control::GetSockOptResponse, optval) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::CloneRequest)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::CloseResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::DescribeResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::OnOpenResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::SyncResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::GetAttrResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrRequest)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::BindRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::BindRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::BindRequest)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::BindRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::BindRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::BindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::BindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::BindResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::BindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::BindResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::ConnectRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::ConnectRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::ConnectRequest)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::ConnectRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::ConnectRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::ConnectResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::ConnectResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::ConnectResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::ConnectResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::ConnectResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::GetSockNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::GetSockNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::GetSockNameResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::GetSockNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::GetSockNameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::GetPeerNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::GetPeerNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::GetPeerNameResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::GetPeerNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::GetPeerNameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptRequest)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptRequest, level) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptRequest, optname) == 18);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptRequest, optval) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::SetSockOptResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptRequest)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptRequest, level) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptRequest, optname) == 18);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptResponse)
+ == ::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::BaseSocket::GetSockOptResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::CloneRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::CloseResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::DescribeResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::OnOpenResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::SyncResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::GetAttrResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::BindRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::BindRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::BindRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::BindRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::BindRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::BindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::BindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::BindResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::BindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::BindResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::ConnectRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::ConnectRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::ConnectRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::ConnectRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::ConnectRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::ConnectResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::ConnectResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::ConnectResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::ConnectResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::ConnectResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::GetSockNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::GetSockNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::GetSockNameResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::GetSockNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::GetSockNameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::GetPeerNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::GetPeerNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::GetPeerNameResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::GetPeerNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::GetPeerNameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptRequest, level) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptRequest, optname) == 18);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptRequest, optval) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::SetSockOptResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptRequest, level) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptRequest, optname) == 18);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::GetSockOptResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::ListenRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::ListenRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::ListenRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::ListenRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::ListenRequest, backlog) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::ListenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::ListenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::ListenResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::ListenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::ListenResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::AcceptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::AcceptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::AcceptRequest)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::AcceptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::AcceptRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::StreamSocket::AcceptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::StreamSocket::AcceptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::StreamSocket::AcceptResponse)
+ == ::llcpp::fuchsia::posix::socket::StreamSocket::AcceptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::StreamSocket::AcceptResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::CloneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::CloneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::CloneRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::CloneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::CloneRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::CloneRequest, object) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::CloseResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::CloseResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::DescribeResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::DescribeResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::DescribeResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::DescribeResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::DescribeResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::OnOpenResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::OnOpenResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::OnOpenResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::OnOpenResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::OnOpenResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::OnOpenResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::SyncResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::SyncResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::SyncResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::SyncResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SyncResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::GetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::GetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetAttrResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::GetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetAttrResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetAttrResponse, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrRequest, flags) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrRequest, attributes) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetAttrResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::NodeGetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::NodeGetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::NodeGetFlagsResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::NodeGetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::NodeGetFlagsResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::NodeGetFlagsResponse, flags) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsRequest, flags) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::NodeSetFlagsResponse, s) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::BindRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::BindRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::BindRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::BindRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::BindRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::BindResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::BindResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::BindResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::BindResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::BindResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectRequest, addr) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::ConnectResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockNameResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockNameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::GetPeerNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::GetPeerNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetPeerNameResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::GetPeerNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetPeerNameResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptRequest, level) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptRequest, optname) == 18);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptRequest, optval) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SetSockOptResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptRequest, level) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptRequest, optname) == 18);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::GetSockOptResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownRequest, how) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::ShutdownResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgRequest, addr_len) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgRequest, data_len) == 20);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgRequest, control_len) == 24);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgRequest, flags) == 28);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::RecvMsgResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgRequest)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgRequest, addr) == 16);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgRequest, data) == 32);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgRequest, control) == 48);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgRequest, flags) == 64);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgResponse)
+ == ::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::posix::socket::DatagramSocket::SendMsgResponse, result) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-process/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-process/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..20fcc0f
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-process/gen/llcpp/fidl.cc
@@ -0,0 +1,861 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/process/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace process {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kResolver_Resolve_Ordinal = 0x20980a8100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kResolver_Resolve_GenOrdinal = 0x3c15951efde89c90lu;
+extern "C" const fidl_type_t v1_fuchsia_process_ResolverResolveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_ResolverResolveResponseTable;
+
+} // namespace
+template <>
+Resolver::ResultOf::Resolve_Impl<Resolver::ResolveResponse>::Resolve_Impl(::zx::unowned_channel _client_end, ::fidl::StringView name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResolveRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ ResolveRequest _request = {};
+ _request.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ResolveRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Resolver::InPlace::Resolve(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Resolver::ResultOf::Resolve Resolver::SyncClient::Resolve(::fidl::StringView name) {
+ return ResultOf::Resolve(::zx::unowned_channel(this->channel_), std::move(name));
+}
+
+Resolver::ResultOf::Resolve Resolver::Call::Resolve(::zx::unowned_channel _client_end, ::fidl::StringView name) {
+ return ResultOf::Resolve(std::move(_client_end), std::move(name));
+}
+
+template <>
+Resolver::UnownedResultOf::Resolve_Impl<Resolver::ResolveResponse>::Resolve_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ResolveRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ResolveResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ ResolveRequest _request = {};
+ _request.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ResolveRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Resolver::InPlace::Resolve(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Resolver::UnownedResultOf::Resolve Resolver::SyncClient::Resolve(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resolve(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(name), std::move(_response_buffer));
+}
+
+Resolver::UnownedResultOf::Resolve Resolver::Call::Resolve(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Resolve(std::move(_client_end), std::move(_request_buffer), std::move(name), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Resolver::ResolveResponse> Resolver::InPlace::Resolve(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResolveRequest> params, ::fidl::BytePart response_buffer) {
+ Resolver::SetTransactionHeaderFor::ResolveRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Resolver::ResolveResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ResolveRequest, ResolveResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Resolver::ResolveResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Resolver::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kResolver_Resolve_Ordinal:
+ case kResolver_Resolve_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ResolveRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Resolve(std::move(message->name),
+ Interface::ResolveCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Resolver::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Resolver::Interface::ResolveCompleterBase::Reply(int32_t status, ::zx::vmo executable, ::zx::channel ldsvc) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ResolveResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ResolveResponse*>(_write_bytes);
+ Resolver::SetTransactionHeaderFor::ResolveResponse(
+ ::fidl::DecodedMessage<ResolveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResolveResponse::PrimarySize,
+ ResolveResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.executable = std::move(executable);
+ _response.ldsvc = std::move(ldsvc);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ResolveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ResolveResponse>(std::move(_response_bytes)));
+}
+
+void Resolver::Interface::ResolveCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::vmo executable, ::zx::channel ldsvc) {
+ if (_buffer.capacity() < ResolveResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ResolveResponse*>(_buffer.data());
+ Resolver::SetTransactionHeaderFor::ResolveResponse(
+ ::fidl::DecodedMessage<ResolveResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ResolveResponse::PrimarySize,
+ ResolveResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.executable = std::move(executable);
+ _response.ldsvc = std::move(ldsvc);
+ _buffer.set_actual(sizeof(ResolveResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ResolveResponse>(std::move(_buffer)));
+}
+
+void Resolver::Interface::ResolveCompleterBase::Reply(::fidl::DecodedMessage<ResolveResponse> params) {
+ Resolver::SetTransactionHeaderFor::ResolveResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Resolver::SetTransactionHeaderFor::ResolveRequest(const ::fidl::DecodedMessage<Resolver::ResolveRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kResolver_Resolve_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Resolver::SetTransactionHeaderFor::ResolveResponse(const ::fidl::DecodedMessage<Resolver::ResolveResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kResolver_Resolve_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLauncher_Launch_Ordinal = 0x26884d9d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_Launch_GenOrdinal = 0x11335a9928afbfa4lu;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherLaunchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherLaunchResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_CreateWithoutStarting_Ordinal = 0x4fcfbc1100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_CreateWithoutStarting_GenOrdinal = 0x755f8263fe51cb61lu;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherCreateWithoutStartingRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherCreateWithoutStartingResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_AddArgs_Ordinal = 0x1480f9a000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_AddArgs_GenOrdinal = 0x3be445d3e4fd6512lu;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddArgsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddArgsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_AddEnvirons_Ordinal = 0x48c62c9900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_AddEnvirons_GenOrdinal = 0x73a3c97fa7fe1779lu;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddEnvironsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddEnvironsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_AddNames_Ordinal = 0x53fcef0c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_AddNames_GenOrdinal = 0x2579ee2c7be28662lu;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddNamesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddNamesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_AddHandles_Ordinal = 0x5cd6900b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLauncher_AddHandles_GenOrdinal = 0x51025267a537a615lu;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddHandlesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddHandlesResponseTable;
+
+} // namespace
+template <>
+Launcher::ResultOf::Launch_Impl<Launcher::LaunchResponse>::Launch_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LaunchRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ LaunchRequest _request = {};
+ _request.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LaunchRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Launcher::InPlace::Launch(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Launcher::ResultOf::Launch Launcher::SyncClient::Launch(::llcpp::fuchsia::process::LaunchInfo info) {
+ return ResultOf::Launch(::zx::unowned_channel(this->channel_), std::move(info));
+}
+
+Launcher::ResultOf::Launch Launcher::Call::Launch(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info) {
+ return ResultOf::Launch(std::move(_client_end), std::move(info));
+}
+
+template <>
+Launcher::UnownedResultOf::Launch_Impl<Launcher::LaunchResponse>::Launch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < LaunchRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<LaunchResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ LaunchRequest _request = {};
+ _request.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<LaunchRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Launcher::InPlace::Launch(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Launcher::UnownedResultOf::Launch Launcher::SyncClient::Launch(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Launch(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(info), std::move(_response_buffer));
+}
+
+Launcher::UnownedResultOf::Launch Launcher::Call::Launch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Launch(std::move(_client_end), std::move(_request_buffer), std::move(info), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Launcher::LaunchResponse> Launcher::InPlace::Launch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LaunchRequest> params, ::fidl::BytePart response_buffer) {
+ Launcher::SetTransactionHeaderFor::LaunchRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Launcher::LaunchResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<LaunchRequest, LaunchResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Launcher::LaunchResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Launcher::ResultOf::CreateWithoutStarting_Impl<Launcher::CreateWithoutStartingResponse>::CreateWithoutStarting_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateWithoutStartingRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ CreateWithoutStartingRequest _request = {};
+ _request.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CreateWithoutStartingRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Launcher::InPlace::CreateWithoutStarting(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Launcher::ResultOf::CreateWithoutStarting Launcher::SyncClient::CreateWithoutStarting(::llcpp::fuchsia::process::LaunchInfo info) {
+ return ResultOf::CreateWithoutStarting(::zx::unowned_channel(this->channel_), std::move(info));
+}
+
+Launcher::ResultOf::CreateWithoutStarting Launcher::Call::CreateWithoutStarting(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info) {
+ return ResultOf::CreateWithoutStarting(std::move(_client_end), std::move(info));
+}
+
+template <>
+Launcher::UnownedResultOf::CreateWithoutStarting_Impl<Launcher::CreateWithoutStartingResponse>::CreateWithoutStarting_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CreateWithoutStartingRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CreateWithoutStartingResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ CreateWithoutStartingRequest _request = {};
+ _request.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CreateWithoutStartingRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Launcher::InPlace::CreateWithoutStarting(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Launcher::UnownedResultOf::CreateWithoutStarting Launcher::SyncClient::CreateWithoutStarting(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateWithoutStarting(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(info), std::move(_response_buffer));
+}
+
+Launcher::UnownedResultOf::CreateWithoutStarting Launcher::Call::CreateWithoutStarting(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateWithoutStarting(std::move(_client_end), std::move(_request_buffer), std::move(info), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Launcher::CreateWithoutStartingResponse> Launcher::InPlace::CreateWithoutStarting(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateWithoutStartingRequest> params, ::fidl::BytePart response_buffer) {
+ Launcher::SetTransactionHeaderFor::CreateWithoutStartingRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Launcher::CreateWithoutStartingResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CreateWithoutStartingRequest, CreateWithoutStartingResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Launcher::CreateWithoutStartingResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+Launcher::ResultOf::AddArgs_Impl::AddArgs_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddArgsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddArgsRequest _request = {};
+ _request.args = std::move(args);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddArgsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Launcher::InPlace::AddArgs(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Launcher::ResultOf::AddArgs Launcher::SyncClient::AddArgs(::fidl::VectorView<::fidl::VectorView<uint8_t>> args) {
+ return ResultOf::AddArgs(::zx::unowned_channel(this->channel_), std::move(args));
+}
+
+Launcher::ResultOf::AddArgs Launcher::Call::AddArgs(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) {
+ return ResultOf::AddArgs(std::move(_client_end), std::move(args));
+}
+
+
+Launcher::UnownedResultOf::AddArgs_Impl::AddArgs_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) {
+ if (_request_buffer.capacity() < AddArgsRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ AddArgsRequest _request = {};
+ _request.args = std::move(args);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddArgsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Launcher::InPlace::AddArgs(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Launcher::UnownedResultOf::AddArgs Launcher::SyncClient::AddArgs(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) {
+ return UnownedResultOf::AddArgs(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(args));
+}
+
+Launcher::UnownedResultOf::AddArgs Launcher::Call::AddArgs(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args) {
+ return UnownedResultOf::AddArgs(std::move(_client_end), std::move(_request_buffer), std::move(args));
+}
+
+::fidl::internal::StatusAndError Launcher::InPlace::AddArgs(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddArgsRequest> params) {
+ Launcher::SetTransactionHeaderFor::AddArgsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Launcher::ResultOf::AddEnvirons_Impl::AddEnvirons_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddEnvironsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddEnvironsRequest _request = {};
+ _request.environ = std::move(environ);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddEnvironsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Launcher::InPlace::AddEnvirons(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Launcher::ResultOf::AddEnvirons Launcher::SyncClient::AddEnvirons(::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) {
+ return ResultOf::AddEnvirons(::zx::unowned_channel(this->channel_), std::move(environ));
+}
+
+Launcher::ResultOf::AddEnvirons Launcher::Call::AddEnvirons(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) {
+ return ResultOf::AddEnvirons(std::move(_client_end), std::move(environ));
+}
+
+
+Launcher::UnownedResultOf::AddEnvirons_Impl::AddEnvirons_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) {
+ if (_request_buffer.capacity() < AddEnvironsRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ AddEnvironsRequest _request = {};
+ _request.environ = std::move(environ);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddEnvironsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Launcher::InPlace::AddEnvirons(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Launcher::UnownedResultOf::AddEnvirons Launcher::SyncClient::AddEnvirons(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) {
+ return UnownedResultOf::AddEnvirons(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(environ));
+}
+
+Launcher::UnownedResultOf::AddEnvirons Launcher::Call::AddEnvirons(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ) {
+ return UnownedResultOf::AddEnvirons(std::move(_client_end), std::move(_request_buffer), std::move(environ));
+}
+
+::fidl::internal::StatusAndError Launcher::InPlace::AddEnvirons(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddEnvironsRequest> params) {
+ Launcher::SetTransactionHeaderFor::AddEnvironsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Launcher::ResultOf::AddNames_Impl::AddNames_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddNamesRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddNamesRequest _request = {};
+ _request.names = std::move(names);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddNamesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Launcher::InPlace::AddNames(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Launcher::ResultOf::AddNames Launcher::SyncClient::AddNames(::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) {
+ return ResultOf::AddNames(::zx::unowned_channel(this->channel_), std::move(names));
+}
+
+Launcher::ResultOf::AddNames Launcher::Call::AddNames(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) {
+ return ResultOf::AddNames(std::move(_client_end), std::move(names));
+}
+
+
+Launcher::UnownedResultOf::AddNames_Impl::AddNames_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) {
+ if (_request_buffer.capacity() < AddNamesRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ AddNamesRequest _request = {};
+ _request.names = std::move(names);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddNamesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Launcher::InPlace::AddNames(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Launcher::UnownedResultOf::AddNames Launcher::SyncClient::AddNames(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) {
+ return UnownedResultOf::AddNames(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(names));
+}
+
+Launcher::UnownedResultOf::AddNames Launcher::Call::AddNames(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names) {
+ return UnownedResultOf::AddNames(std::move(_client_end), std::move(_request_buffer), std::move(names));
+}
+
+::fidl::internal::StatusAndError Launcher::InPlace::AddNames(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddNamesRequest> params) {
+ Launcher::SetTransactionHeaderFor::AddNamesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Launcher::ResultOf::AddHandles_Impl::AddHandles_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AddHandlesRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ AddHandlesRequest _request = {};
+ _request.handles = std::move(handles);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddHandlesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Launcher::InPlace::AddHandles(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Launcher::ResultOf::AddHandles Launcher::SyncClient::AddHandles(::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) {
+ return ResultOf::AddHandles(::zx::unowned_channel(this->channel_), std::move(handles));
+}
+
+Launcher::ResultOf::AddHandles Launcher::Call::AddHandles(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) {
+ return ResultOf::AddHandles(std::move(_client_end), std::move(handles));
+}
+
+
+Launcher::UnownedResultOf::AddHandles_Impl::AddHandles_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) {
+ if (_request_buffer.capacity() < AddHandlesRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ AddHandlesRequest _request = {};
+ _request.handles = std::move(handles);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<AddHandlesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ Launcher::InPlace::AddHandles(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Launcher::UnownedResultOf::AddHandles Launcher::SyncClient::AddHandles(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) {
+ return UnownedResultOf::AddHandles(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(handles));
+}
+
+Launcher::UnownedResultOf::AddHandles Launcher::Call::AddHandles(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles) {
+ return UnownedResultOf::AddHandles(std::move(_client_end), std::move(_request_buffer), std::move(handles));
+}
+
+::fidl::internal::StatusAndError Launcher::InPlace::AddHandles(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddHandlesRequest> params) {
+ Launcher::SetTransactionHeaderFor::AddHandlesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Launcher::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kLauncher_Launch_Ordinal:
+ case kLauncher_Launch_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<LaunchRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Launch(std::move(message->info),
+ Interface::LaunchCompleter::Sync(txn));
+ return true;
+ }
+ case kLauncher_CreateWithoutStarting_Ordinal:
+ case kLauncher_CreateWithoutStarting_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateWithoutStartingRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateWithoutStarting(std::move(message->info),
+ Interface::CreateWithoutStartingCompleter::Sync(txn));
+ return true;
+ }
+ case kLauncher_AddArgs_Ordinal:
+ case kLauncher_AddArgs_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddArgsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddArgs(std::move(message->args),
+ Interface::AddArgsCompleter::Sync(txn));
+ return true;
+ }
+ case kLauncher_AddEnvirons_Ordinal:
+ case kLauncher_AddEnvirons_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddEnvironsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddEnvirons(std::move(message->environ),
+ Interface::AddEnvironsCompleter::Sync(txn));
+ return true;
+ }
+ case kLauncher_AddNames_Ordinal:
+ case kLauncher_AddNames_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddNamesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddNames(std::move(message->names),
+ Interface::AddNamesCompleter::Sync(txn));
+ return true;
+ }
+ case kLauncher_AddHandles_Ordinal:
+ case kLauncher_AddHandles_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AddHandlesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AddHandles(std::move(message->handles),
+ Interface::AddHandlesCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Launcher::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Launcher::Interface::LaunchCompleterBase::Reply(int32_t status, ::zx::process process) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<LaunchResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<LaunchResponse*>(_write_bytes);
+ Launcher::SetTransactionHeaderFor::LaunchResponse(
+ ::fidl::DecodedMessage<LaunchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LaunchResponse::PrimarySize,
+ LaunchResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.process = std::move(process);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(LaunchResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LaunchResponse>(std::move(_response_bytes)));
+}
+
+void Launcher::Interface::LaunchCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::process process) {
+ if (_buffer.capacity() < LaunchResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<LaunchResponse*>(_buffer.data());
+ Launcher::SetTransactionHeaderFor::LaunchResponse(
+ ::fidl::DecodedMessage<LaunchResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ LaunchResponse::PrimarySize,
+ LaunchResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.process = std::move(process);
+ _buffer.set_actual(sizeof(LaunchResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<LaunchResponse>(std::move(_buffer)));
+}
+
+void Launcher::Interface::LaunchCompleterBase::Reply(::fidl::DecodedMessage<LaunchResponse> params) {
+ Launcher::SetTransactionHeaderFor::LaunchResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Launcher::Interface::CreateWithoutStartingCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::process::ProcessStartData* data) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateWithoutStartingResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ CreateWithoutStartingResponse _response = {};
+ Launcher::SetTransactionHeaderFor::CreateWithoutStartingResponse(
+ ::fidl::DecodedMessage<CreateWithoutStartingResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateWithoutStartingResponse::PrimarySize,
+ CreateWithoutStartingResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Launcher::Interface::CreateWithoutStartingCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::process::ProcessStartData* data) {
+ if (_buffer.capacity() < CreateWithoutStartingResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CreateWithoutStartingResponse _response = {};
+ Launcher::SetTransactionHeaderFor::CreateWithoutStartingResponse(
+ ::fidl::DecodedMessage<CreateWithoutStartingResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateWithoutStartingResponse::PrimarySize,
+ CreateWithoutStartingResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.data = std::move(data);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Launcher::Interface::CreateWithoutStartingCompleterBase::Reply(::fidl::DecodedMessage<CreateWithoutStartingResponse> params) {
+ Launcher::SetTransactionHeaderFor::CreateWithoutStartingResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Launcher::SetTransactionHeaderFor::LaunchRequest(const ::fidl::DecodedMessage<Launcher::LaunchRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_Launch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Launcher::SetTransactionHeaderFor::LaunchResponse(const ::fidl::DecodedMessage<Launcher::LaunchResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_Launch_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Launcher::SetTransactionHeaderFor::CreateWithoutStartingRequest(const ::fidl::DecodedMessage<Launcher::CreateWithoutStartingRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_CreateWithoutStarting_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Launcher::SetTransactionHeaderFor::CreateWithoutStartingResponse(const ::fidl::DecodedMessage<Launcher::CreateWithoutStartingResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_CreateWithoutStarting_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Launcher::SetTransactionHeaderFor::AddArgsRequest(const ::fidl::DecodedMessage<Launcher::AddArgsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_AddArgs_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Launcher::SetTransactionHeaderFor::AddEnvironsRequest(const ::fidl::DecodedMessage<Launcher::AddEnvironsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_AddEnvirons_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Launcher::SetTransactionHeaderFor::AddNamesRequest(const ::fidl::DecodedMessage<Launcher::AddNamesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_AddNames_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Launcher::SetTransactionHeaderFor::AddHandlesRequest(const ::fidl::DecodedMessage<Launcher::AddHandlesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLauncher_AddHandles_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace process
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-process/gen/llcpp/include/fuchsia/process/llcpp/fidl.h b/zircon/system/fidl/fuchsia-process/gen/llcpp/include/fuchsia/process/llcpp/fidl.h
new file mode 100644
index 0000000..4f5916a
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-process/gen/llcpp/include/fuchsia/process/llcpp/fidl.h
@@ -0,0 +1,1262 @@
+// 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/handle.h>
+#include <lib/zx/job.h>
+#include <lib/zx/process.h>
+#include <lib/zx/thread.h>
+#include <lib/zx/vmar.h>
+#include <lib/zx/vmo.h>
+#include <zircon/fidl.h>
+
+#include <fuchsia/io/llcpp/fidl.h>
+#include <fuchsia/ldsvc/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace process {
+
+struct ProcessStartData;
+struct HandleInfo;
+class Resolver;
+struct NameInfo;
+struct LaunchInfo;
+class Launcher;
+
+extern "C" const fidl_type_t v1_fuchsia_process_ProcessStartDataTable;
+
+// The information required to start a process.
+//
+// To start the process, call `zx_process_start` with the arguments provided.
+struct ProcessStartData {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_ProcessStartDataTable;
+ static constexpr uint32_t MaxNumHandles = 4;
+ static constexpr uint32_t PrimarySize = 56;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The process that was created.
+ ::zx::process process = {};
+
+ // The vmar object that was created when the process was created.
+ //
+ // See <https://fuchsia.dev/fuchsia-src/reference/syscalls/process_create.md>.
+ ::zx::vmar root_vmar = {};
+
+ // The initial thread for the process.
+ //
+ // Should be passed to `zx_process_start` when starting the process.
+ ::zx::thread thread = {};
+
+ // The address of the initial entry point in the process.
+ //
+ // Should be passed to `zx_process_start` when starting the process.
+ uint64_t entry = {};
+
+ // The stack pointer value for the initial thread of the process.
+ //
+ // Should be passed to `zx_process_start` when starting the process.
+ uint64_t stack = {};
+
+ // The bootstrap channel to pass to the process on startup.
+ //
+ // Should be passed to `zx_process_start` when starting the process.
+ ::zx::channel bootstrap = {};
+
+ // The base address of the vDSO to pass to the process on startup.
+ //
+ // Should be passed to `zx_process_start` when starting the process.
+ uint64_t vdso_base = {};
+
+ // The base load address of the ELF file loaded.
+ //
+ // Most often used by debuggers or other tools that inspect the process.
+ uint64_t base = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_process_HandleInfoTable;
+
+// Information about a handle provided to a process at startup.
+//
+// Processes are given a set of initial handles as part of the bootstrapping
+// sequence. Some of these handles are associated with zx.procarg identifiers
+// that designate their intended use by the new process.
+//
+// This structure represents one such handle and its associated zx.procarg
+// identifier.
+struct HandleInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_HandleInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The handle to use for this process argument.
+ ::zx::handle handle = {};
+
+ // Process argument identifier.
+ //
+ // See <zircon/processargs.h> for definitions of well-known process
+ // arguments.
+ uint32_t id = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_process_ResolverResolveRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_ResolverResolveResponseTable;
+
+// An interface for resolving names to executables and library loaders.
+//
+// An executable itself is often not sufficient to create a working process
+// because many executables also load shared libraries. On Fuchsia, there is no
+// global pool of shared libraries. Instead, every process has an associated
+// `fuchsia.ldsvc.Loader`, which provides access to a private pool of shared
+// libraries appropriate for that process.
+//
+// This interface provides a protocol for resolving a name into both the
+// `handle<vmo>` for the executable and the `fuchsia.ldsvc.Loader` for its
+// associated shared libraries.
+//
+// This interface is rarely used directly. Instead, `fdio_spawn` and
+// `fdio_spawn_etc` use this interface internally when they try to run a file
+// with a `#!resolve` directive.
+class Resolver final {
+ Resolver() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.process.Resolver";
+
+ struct ResolveResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::vmo executable;
+ ::zx::channel ldsvc;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_ResolverResolveResponseTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 ResolveRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView name;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_ResolverResolveRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 2048;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 2048;
+ 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 = ResolveResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Resolve_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Resolve_Impl(::zx::unowned_channel _client_end, ::fidl::StringView name);
+ ~Resolve_Impl() = default;
+ Resolve_Impl(Resolve_Impl&& other) = default;
+ Resolve_Impl& operator=(Resolve_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 Resolve = Resolve_Impl<ResolveResponse>;
+ };
+
+ // 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 Resolve_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Resolve_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::fidl::BytePart _response_buffer);
+ ~Resolve_Impl() = default;
+ Resolve_Impl(Resolve_Impl&& other) = default;
+ Resolve_Impl& operator=(Resolve_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 Resolve = Resolve_Impl<ResolveResponse>;
+ };
+
+ 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_; }
+
+ // Resolves the given `name` to an `executable` and an shared library
+ // loader.
+ //
+ // If present, the `executable` is suitable for use as the `executable`
+ // property of `LaunchInfo`. If present, the `ldsvc` is suitable for use as
+ // the `PA_LDSVC_LOADER` handle when launching the process.
+ //
+ // For example, the resolver might locate the given `name` inside a package
+ // and return the executable binary from the package as well as a shared
+ // library loader scoped to that package.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::Resolve Resolve(::fidl::StringView name);
+
+ // Resolves the given `name` to an `executable` and an shared library
+ // loader.
+ //
+ // If present, the `executable` is suitable for use as the `executable`
+ // property of `LaunchInfo`. If present, the `ldsvc` is suitable for use as
+ // the `PA_LDSVC_LOADER` handle when launching the process.
+ //
+ // For example, the resolver might locate the given `name` inside a package
+ // and return the executable binary from the package as well as a shared
+ // library loader scoped to that package.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Resolve Resolve(::fidl::BytePart _request_buffer, ::fidl::StringView name, ::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:
+
+ // Resolves the given `name` to an `executable` and an shared library
+ // loader.
+ //
+ // If present, the `executable` is suitable for use as the `executable`
+ // property of `LaunchInfo`. If present, the `ldsvc` is suitable for use as
+ // the `PA_LDSVC_LOADER` handle when launching the process.
+ //
+ // For example, the resolver might locate the given `name` inside a package
+ // and return the executable binary from the package as well as a shared
+ // library loader scoped to that package.
+ // Allocates 32 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::Resolve Resolve(::zx::unowned_channel _client_end, ::fidl::StringView name);
+
+ // Resolves the given `name` to an `executable` and an shared library
+ // loader.
+ //
+ // If present, the `executable` is suitable for use as the `executable`
+ // property of `LaunchInfo`. If present, the `ldsvc` is suitable for use as
+ // the `PA_LDSVC_LOADER` handle when launching the process.
+ //
+ // For example, the resolver might locate the given `name` inside a package
+ // and return the executable binary from the package as well as a shared
+ // library loader scoped to that package.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Resolve Resolve(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView name, ::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:
+
+ // Resolves the given `name` to an `executable` and an shared library
+ // loader.
+ //
+ // If present, the `executable` is suitable for use as the `executable`
+ // property of `LaunchInfo`. If present, the `ldsvc` is suitable for use as
+ // the `PA_LDSVC_LOADER` handle when launching the process.
+ //
+ // For example, the resolver might locate the given `name` inside a package
+ // and return the executable binary from the package as well as a shared
+ // library loader scoped to that package.
+ static ::fidl::DecodeResult<ResolveResponse> Resolve(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ResolveRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Resolver;
+ using _Base = ::fidl::CompleterBase;
+
+ class ResolveCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::vmo executable, ::zx::channel ldsvc);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::vmo executable, ::zx::channel ldsvc);
+ void Reply(::fidl::DecodedMessage<ResolveResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ResolveCompleter = ::fidl::Completer<ResolveCompleterBase>;
+
+ virtual void Resolve(::fidl::StringView name, ResolveCompleter::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 ResolveRequest(const ::fidl::DecodedMessage<Resolver::ResolveRequest>& _msg);
+ static void ResolveResponse(const ::fidl::DecodedMessage<Resolver::ResolveResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_process_NameInfoTable;
+
+// A namespace entry provided to a process at startup.
+//
+// Processes are given a set of initial handles as part of the bootstrapping
+// sequence. Some of these handles are associated with paths that designate
+// their intended use by the new process as namespace entries.
+//
+// This structure represents one such handle and its associated namespace path.
+struct NameInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_NameInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 4096;
+ static constexpr bool HasPointer = true;
+
+ // Path at which to install the associated directory.
+ //
+ // Must be an absolute path (i.e., start with '/').
+ ::fidl::StringView path = {};
+
+ // The associated directory.
+ ::zx::channel directory = {};
+};
+
+// The maximum size for a name used by `Resolver`.
+constexpr uint32_t MAX_RESOLVE_NAME_SIZE = 2048u;
+
+constexpr uint32_t MAX = 4294967295u;
+
+extern "C" const fidl_type_t v1_fuchsia_process_LaunchInfoTable;
+
+// The information needed to launch a process.
+struct LaunchInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LaunchInfoTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 32;
+ static constexpr bool HasPointer = true;
+
+ // The executable to run in the process.
+ ::zx::vmo executable = {};
+
+ // The job in which to create the process.
+ ::zx::job job = {};
+
+ // The name to assign to the created process.
+ ::fidl::StringView name = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherLaunchRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherLaunchResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherCreateWithoutStartingRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherCreateWithoutStartingResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddArgsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddArgsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddEnvironsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddEnvironsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddNamesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddNamesResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddHandlesRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_process_LauncherAddHandlesResponseTable;
+
+// A low-level interface for launching processes.
+//
+// This interface is used for manually assembling a process. The caller supplies
+// all the capabilities for the newly created process.
+//
+// That create processes typically use `fdio_spawn` or `fdio_spawn_etc` rather
+// than using this interface directly. The `fdio_spawn` and `fdio_spawn_etc`
+// functions are implemented using this interface.
+//
+// Debuggers and other clients that need to create processes in a suspended
+// state often use this interface directly. These clients use the
+// `CreateWithoutStarting` method to create the process without actually
+// starting it.
+class Launcher final {
+ Launcher() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.process.Launcher";
+
+ struct LaunchResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::process process;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LauncherLaunchResponseTable;
+ 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;
+ };
+ struct LaunchRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::process::LaunchInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LauncherLaunchRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 32;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 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::kRequest;
+ using ResponseType = LaunchResponse;
+ };
+
+ struct CreateWithoutStartingResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::process::ProcessStartData* data;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LauncherCreateWithoutStartingResponseTable;
+ static constexpr uint32_t MaxNumHandles = 4;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 56;
+ 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 CreateWithoutStartingRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::process::LaunchInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LauncherCreateWithoutStartingRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 32;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 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::kRequest;
+ using ResponseType = CreateWithoutStartingResponse;
+ };
+
+ struct AddArgsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::fidl::VectorView<uint8_t>> args;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LauncherAddArgsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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;
+ };
+
+ struct AddEnvironsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LauncherAddEnvironsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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;
+ };
+
+ struct AddNamesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LauncherAddNamesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 4294967295;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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;
+ };
+
+ struct AddHandlesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_process_LauncherAddHandlesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 4294967295;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Launch_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Launch_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info);
+ ~Launch_Impl() = default;
+ Launch_Impl(Launch_Impl&& other) = default;
+ Launch_Impl& operator=(Launch_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 CreateWithoutStarting_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CreateWithoutStarting_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info);
+ ~CreateWithoutStarting_Impl() = default;
+ CreateWithoutStarting_Impl(CreateWithoutStarting_Impl&& other) = default;
+ CreateWithoutStarting_Impl& operator=(CreateWithoutStarting_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class AddArgs_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddArgs_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args);
+ ~AddArgs_Impl() = default;
+ AddArgs_Impl(AddArgs_Impl&& other) = default;
+ AddArgs_Impl& operator=(AddArgs_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AddEnvirons_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddEnvirons_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ);
+ ~AddEnvirons_Impl() = default;
+ AddEnvirons_Impl(AddEnvirons_Impl&& other) = default;
+ AddEnvirons_Impl& operator=(AddEnvirons_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AddNames_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddNames_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names);
+ ~AddNames_Impl() = default;
+ AddNames_Impl(AddNames_Impl&& other) = default;
+ AddNames_Impl& operator=(AddNames_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AddHandles_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddHandles_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles);
+ ~AddHandles_Impl() = default;
+ AddHandles_Impl(AddHandles_Impl&& other) = default;
+ AddHandles_Impl& operator=(AddHandles_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Launch = Launch_Impl<LaunchResponse>;
+ using CreateWithoutStarting = CreateWithoutStarting_Impl<CreateWithoutStartingResponse>;
+ using AddArgs = AddArgs_Impl;
+ using AddEnvirons = AddEnvirons_Impl;
+ using AddNames = AddNames_Impl;
+ using AddHandles = AddHandles_Impl;
+ };
+
+ // 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 Launch_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Launch_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer);
+ ~Launch_Impl() = default;
+ Launch_Impl(Launch_Impl&& other) = default;
+ Launch_Impl& operator=(Launch_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 CreateWithoutStarting_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CreateWithoutStarting_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer);
+ ~CreateWithoutStarting_Impl() = default;
+ CreateWithoutStarting_Impl(CreateWithoutStarting_Impl&& other) = default;
+ CreateWithoutStarting_Impl& operator=(CreateWithoutStarting_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class AddArgs_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddArgs_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args);
+ ~AddArgs_Impl() = default;
+ AddArgs_Impl(AddArgs_Impl&& other) = default;
+ AddArgs_Impl& operator=(AddArgs_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AddEnvirons_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddEnvirons_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ);
+ ~AddEnvirons_Impl() = default;
+ AddEnvirons_Impl(AddEnvirons_Impl&& other) = default;
+ AddEnvirons_Impl& operator=(AddEnvirons_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AddNames_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddNames_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names);
+ ~AddNames_Impl() = default;
+ AddNames_Impl(AddNames_Impl&& other) = default;
+ AddNames_Impl& operator=(AddNames_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AddHandles_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AddHandles_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles);
+ ~AddHandles_Impl() = default;
+ AddHandles_Impl(AddHandles_Impl&& other) = default;
+ AddHandles_Impl& operator=(AddHandles_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Launch = Launch_Impl<LaunchResponse>;
+ using CreateWithoutStarting = CreateWithoutStarting_Impl<CreateWithoutStartingResponse>;
+ using AddArgs = AddArgs_Impl;
+ using AddEnvirons = AddEnvirons_Impl;
+ using AddNames = AddNames_Impl;
+ using AddHandles = AddHandles_Impl;
+ };
+
+ 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_; }
+
+ // Creates and starts the process described by `info`.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // `process` is present if, and only if, `status` is `ZX_OK`.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Launch Launch(::llcpp::fuchsia::process::LaunchInfo info);
+
+ // Creates and starts the process described by `info`.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // `process` is present if, and only if, `status` is `ZX_OK`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Launch Launch(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer);
+
+ // Creates the process described by `info` but does not start it.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // The caller is responsible for calling `zx_process_start` using the data
+ // in `ProcessStartData` to actually start the process.
+ //
+ // `data` is present if, and only if, `status` is `ZX_OK`.
+ // Allocates 160 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateWithoutStarting CreateWithoutStarting(::llcpp::fuchsia::process::LaunchInfo info);
+
+ // Creates the process described by `info` but does not start it.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // The caller is responsible for calling `zx_process_start` using the data
+ // in `ProcessStartData` to actually start the process.
+ //
+ // `data` is present if, and only if, `status` is `ZX_OK`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateWithoutStarting CreateWithoutStarting(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer);
+
+ // Adds the given arguments to the command-line for the process.
+ //
+ // Calling this method multiple times concatenates the arguments.
+ // Request is heap-allocated.
+ ResultOf::AddArgs AddArgs(::fidl::VectorView<::fidl::VectorView<uint8_t>> args);
+
+ // Adds the given arguments to the command-line for the process.
+ //
+ // Calling this method multiple times concatenates the arguments.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddArgs AddArgs(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args);
+
+ // Adds the given variables to the environment variables for the process.
+ //
+ // Calling this method multiple times concatenates the variables.
+ // Request is heap-allocated.
+ ResultOf::AddEnvirons AddEnvirons(::fidl::VectorView<::fidl::VectorView<uint8_t>> environ);
+
+ // Adds the given variables to the environment variables for the process.
+ //
+ // Calling this method multiple times concatenates the variables.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddEnvirons AddEnvirons(::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ);
+
+ // Adds the given names to the namespace for the process.
+ //
+ // The paths in the namespace must be non-overlapping. See
+ // <https://fuchsia.dev/fuchsia-src/concepts/framework/namespaces> for details.
+ //
+ // Calling this method multiple times concatenates the names.
+ // Request is heap-allocated.
+ ResultOf::AddNames AddNames(::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names);
+
+ // Adds the given names to the namespace for the process.
+ //
+ // The paths in the namespace must be non-overlapping. See
+ // <https://fuchsia.dev/fuchsia-src/concepts/framework/namespaces> for details.
+ //
+ // Calling this method multiple times concatenates the names.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddNames AddNames(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names);
+
+ // Adds the given handles to the startup handles for the process.
+ //
+ // Calling this method multiple times concatenates the handles.
+ // Request is heap-allocated.
+ ResultOf::AddHandles AddHandles(::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles);
+
+ // Adds the given handles to the startup handles for the process.
+ //
+ // Calling this method multiple times concatenates the handles.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AddHandles AddHandles(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles);
+
+ 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:
+
+ // Creates and starts the process described by `info`.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // `process` is present if, and only if, `status` is `ZX_OK`.
+ // Allocates 96 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Launch Launch(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info);
+
+ // Creates and starts the process described by `info`.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // `process` is present if, and only if, `status` is `ZX_OK`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Launch Launch(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer);
+
+ // Creates the process described by `info` but does not start it.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // The caller is responsible for calling `zx_process_start` using the data
+ // in `ProcessStartData` to actually start the process.
+ //
+ // `data` is present if, and only if, `status` is `ZX_OK`.
+ // Allocates 160 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateWithoutStarting CreateWithoutStarting(::zx::unowned_channel _client_end, ::llcpp::fuchsia::process::LaunchInfo info);
+
+ // Creates the process described by `info` but does not start it.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // The caller is responsible for calling `zx_process_start` using the data
+ // in `ProcessStartData` to actually start the process.
+ //
+ // `data` is present if, and only if, `status` is `ZX_OK`.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateWithoutStarting CreateWithoutStarting(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::process::LaunchInfo info, ::fidl::BytePart _response_buffer);
+
+ // Adds the given arguments to the command-line for the process.
+ //
+ // Calling this method multiple times concatenates the arguments.
+ // Request is heap-allocated.
+ static ResultOf::AddArgs AddArgs(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args);
+
+ // Adds the given arguments to the command-line for the process.
+ //
+ // Calling this method multiple times concatenates the arguments.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddArgs AddArgs(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> args);
+
+ // Adds the given variables to the environment variables for the process.
+ //
+ // Calling this method multiple times concatenates the variables.
+ // Request is heap-allocated.
+ static ResultOf::AddEnvirons AddEnvirons(::zx::unowned_channel _client_end, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ);
+
+ // Adds the given variables to the environment variables for the process.
+ //
+ // Calling this method multiple times concatenates the variables.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddEnvirons AddEnvirons(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::fidl::VectorView<uint8_t>> environ);
+
+ // Adds the given names to the namespace for the process.
+ //
+ // The paths in the namespace must be non-overlapping. See
+ // <https://fuchsia.dev/fuchsia-src/concepts/framework/namespaces> for details.
+ //
+ // Calling this method multiple times concatenates the names.
+ // Request is heap-allocated.
+ static ResultOf::AddNames AddNames(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names);
+
+ // Adds the given names to the namespace for the process.
+ //
+ // The paths in the namespace must be non-overlapping. See
+ // <https://fuchsia.dev/fuchsia-src/concepts/framework/namespaces> for details.
+ //
+ // Calling this method multiple times concatenates the names.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddNames AddNames(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names);
+
+ // Adds the given handles to the startup handles for the process.
+ //
+ // Calling this method multiple times concatenates the handles.
+ // Request is heap-allocated.
+ static ResultOf::AddHandles AddHandles(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles);
+
+ // Adds the given handles to the startup handles for the process.
+ //
+ // Calling this method multiple times concatenates the handles.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AddHandles AddHandles(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles);
+
+ };
+
+ // 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:
+
+ // Creates and starts the process described by `info`.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // `process` is present if, and only if, `status` is `ZX_OK`.
+ static ::fidl::DecodeResult<LaunchResponse> Launch(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<LaunchRequest> params, ::fidl::BytePart response_buffer);
+
+ // Creates the process described by `info` but does not start it.
+ //
+ // After processing this message, the `Launcher` is reset to its initial
+ // state and is ready to launch another process.
+ //
+ // The caller is responsible for calling `zx_process_start` using the data
+ // in `ProcessStartData` to actually start the process.
+ //
+ // `data` is present if, and only if, `status` is `ZX_OK`.
+ static ::fidl::DecodeResult<CreateWithoutStartingResponse> CreateWithoutStarting(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateWithoutStartingRequest> params, ::fidl::BytePart response_buffer);
+
+ // Adds the given arguments to the command-line for the process.
+ //
+ // Calling this method multiple times concatenates the arguments.
+ static ::fidl::internal::StatusAndError AddArgs(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddArgsRequest> params);
+
+ // Adds the given variables to the environment variables for the process.
+ //
+ // Calling this method multiple times concatenates the variables.
+ static ::fidl::internal::StatusAndError AddEnvirons(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddEnvironsRequest> params);
+
+ // Adds the given names to the namespace for the process.
+ //
+ // The paths in the namespace must be non-overlapping. See
+ // <https://fuchsia.dev/fuchsia-src/concepts/framework/namespaces> for details.
+ //
+ // Calling this method multiple times concatenates the names.
+ static ::fidl::internal::StatusAndError AddNames(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddNamesRequest> params);
+
+ // Adds the given handles to the startup handles for the process.
+ //
+ // Calling this method multiple times concatenates the handles.
+ static ::fidl::internal::StatusAndError AddHandles(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AddHandlesRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Launcher;
+ using _Base = ::fidl::CompleterBase;
+
+ class LaunchCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::process process);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::process process);
+ void Reply(::fidl::DecodedMessage<LaunchResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using LaunchCompleter = ::fidl::Completer<LaunchCompleterBase>;
+
+ virtual void Launch(::llcpp::fuchsia::process::LaunchInfo info, LaunchCompleter::Sync _completer) = 0;
+
+ class CreateWithoutStartingCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::process::ProcessStartData* data);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::process::ProcessStartData* data);
+ void Reply(::fidl::DecodedMessage<CreateWithoutStartingResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CreateWithoutStartingCompleter = ::fidl::Completer<CreateWithoutStartingCompleterBase>;
+
+ virtual void CreateWithoutStarting(::llcpp::fuchsia::process::LaunchInfo info, CreateWithoutStartingCompleter::Sync _completer) = 0;
+
+ using AddArgsCompleter = ::fidl::Completer<>;
+
+ virtual void AddArgs(::fidl::VectorView<::fidl::VectorView<uint8_t>> args, AddArgsCompleter::Sync _completer) = 0;
+
+ using AddEnvironsCompleter = ::fidl::Completer<>;
+
+ virtual void AddEnvirons(::fidl::VectorView<::fidl::VectorView<uint8_t>> environ, AddEnvironsCompleter::Sync _completer) = 0;
+
+ using AddNamesCompleter = ::fidl::Completer<>;
+
+ virtual void AddNames(::fidl::VectorView<::llcpp::fuchsia::process::NameInfo> names, AddNamesCompleter::Sync _completer) = 0;
+
+ using AddHandlesCompleter = ::fidl::Completer<>;
+
+ virtual void AddHandles(::fidl::VectorView<::llcpp::fuchsia::process::HandleInfo> handles, AddHandlesCompleter::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 LaunchRequest(const ::fidl::DecodedMessage<Launcher::LaunchRequest>& _msg);
+ static void LaunchResponse(const ::fidl::DecodedMessage<Launcher::LaunchResponse>& _msg);
+ static void CreateWithoutStartingRequest(const ::fidl::DecodedMessage<Launcher::CreateWithoutStartingRequest>& _msg);
+ static void CreateWithoutStartingResponse(const ::fidl::DecodedMessage<Launcher::CreateWithoutStartingResponse>& _msg);
+ static void AddArgsRequest(const ::fidl::DecodedMessage<Launcher::AddArgsRequest>& _msg);
+ static void AddEnvironsRequest(const ::fidl::DecodedMessage<Launcher::AddEnvironsRequest>& _msg);
+ static void AddNamesRequest(const ::fidl::DecodedMessage<Launcher::AddNamesRequest>& _msg);
+ static void AddHandlesRequest(const ::fidl::DecodedMessage<Launcher::AddHandlesRequest>& _msg);
+ };
+};
+
+} // namespace process
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::ProcessStartData> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::process::ProcessStartData>);
+static_assert(offsetof(::llcpp::fuchsia::process::ProcessStartData, process) == 0);
+static_assert(offsetof(::llcpp::fuchsia::process::ProcessStartData, root_vmar) == 4);
+static_assert(offsetof(::llcpp::fuchsia::process::ProcessStartData, thread) == 8);
+static_assert(offsetof(::llcpp::fuchsia::process::ProcessStartData, entry) == 16);
+static_assert(offsetof(::llcpp::fuchsia::process::ProcessStartData, stack) == 24);
+static_assert(offsetof(::llcpp::fuchsia::process::ProcessStartData, bootstrap) == 32);
+static_assert(offsetof(::llcpp::fuchsia::process::ProcessStartData, vdso_base) == 40);
+static_assert(offsetof(::llcpp::fuchsia::process::ProcessStartData, base) == 48);
+static_assert(sizeof(::llcpp::fuchsia::process::ProcessStartData) == ::llcpp::fuchsia::process::ProcessStartData::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::HandleInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::process::HandleInfo>);
+static_assert(offsetof(::llcpp::fuchsia::process::HandleInfo, handle) == 0);
+static_assert(offsetof(::llcpp::fuchsia::process::HandleInfo, id) == 4);
+static_assert(sizeof(::llcpp::fuchsia::process::HandleInfo) == ::llcpp::fuchsia::process::HandleInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Resolver::ResolveRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Resolver::ResolveRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Resolver::ResolveRequest)
+ == ::llcpp::fuchsia::process::Resolver::ResolveRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Resolver::ResolveRequest, name) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Resolver::ResolveResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Resolver::ResolveResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Resolver::ResolveResponse)
+ == ::llcpp::fuchsia::process::Resolver::ResolveResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Resolver::ResolveResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::process::Resolver::ResolveResponse, executable) == 20);
+static_assert(offsetof(::llcpp::fuchsia::process::Resolver::ResolveResponse, ldsvc) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::NameInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::process::NameInfo>);
+static_assert(offsetof(::llcpp::fuchsia::process::NameInfo, path) == 0);
+static_assert(offsetof(::llcpp::fuchsia::process::NameInfo, directory) == 16);
+static_assert(sizeof(::llcpp::fuchsia::process::NameInfo) == ::llcpp::fuchsia::process::NameInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::LaunchInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::process::LaunchInfo>);
+static_assert(offsetof(::llcpp::fuchsia::process::LaunchInfo, executable) == 0);
+static_assert(offsetof(::llcpp::fuchsia::process::LaunchInfo, job) == 4);
+static_assert(offsetof(::llcpp::fuchsia::process::LaunchInfo, name) == 8);
+static_assert(sizeof(::llcpp::fuchsia::process::LaunchInfo) == ::llcpp::fuchsia::process::LaunchInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Launcher::LaunchRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Launcher::LaunchRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Launcher::LaunchRequest)
+ == ::llcpp::fuchsia::process::Launcher::LaunchRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::LaunchRequest, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Launcher::LaunchResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Launcher::LaunchResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Launcher::LaunchResponse)
+ == ::llcpp::fuchsia::process::Launcher::LaunchResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::LaunchResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::LaunchResponse, process) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Launcher::CreateWithoutStartingRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Launcher::CreateWithoutStartingRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Launcher::CreateWithoutStartingRequest)
+ == ::llcpp::fuchsia::process::Launcher::CreateWithoutStartingRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::CreateWithoutStartingRequest, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Launcher::CreateWithoutStartingResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Launcher::CreateWithoutStartingResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Launcher::CreateWithoutStartingResponse)
+ == ::llcpp::fuchsia::process::Launcher::CreateWithoutStartingResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::CreateWithoutStartingResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::CreateWithoutStartingResponse, data) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Launcher::AddArgsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Launcher::AddArgsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Launcher::AddArgsRequest)
+ == ::llcpp::fuchsia::process::Launcher::AddArgsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::AddArgsRequest, args) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Launcher::AddEnvironsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Launcher::AddEnvironsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Launcher::AddEnvironsRequest)
+ == ::llcpp::fuchsia::process::Launcher::AddEnvironsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::AddEnvironsRequest, environ) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Launcher::AddNamesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Launcher::AddNamesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Launcher::AddNamesRequest)
+ == ::llcpp::fuchsia::process::Launcher::AddNamesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::AddNamesRequest, names) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::process::Launcher::AddHandlesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::process::Launcher::AddHandlesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::process::Launcher::AddHandlesRequest)
+ == ::llcpp::fuchsia::process::Launcher::AddHandlesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::process::Launcher::AddHandlesRequest, handles) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-storage-metrics/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-storage-metrics/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..b7543ee
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-storage-metrics/gen/llcpp/fidl.cc
@@ -0,0 +1,15 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/storage/metrics/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace storage {
+namespace metrics {
+
+} // namespace metrics
+} // namespace storage
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-storage-metrics/gen/llcpp/include/fuchsia/storage/metrics/llcpp/fidl.h b/zircon/system/fidl/fuchsia-storage-metrics/gen/llcpp/include/fuchsia/storage/metrics/llcpp/fidl.h
new file mode 100644
index 0000000..a19d761
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-storage-metrics/gen/llcpp/include/fuchsia/storage/metrics/llcpp/fidl.h
@@ -0,0 +1,129 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace storage {
+namespace metrics {
+
+struct CallStatRaw;
+struct CallStat;
+struct FsMetrics;
+
+extern "C" const fidl_type_t v1_fuchsia_storage_metrics_CallStatRawTable;
+
+struct CallStatRaw {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_storage_metrics_CallStatRawTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint64_t minimum_latency = {};
+
+ uint64_t maximum_latency = {};
+
+ uint64_t total_time_spent = {};
+
+ uint64_t total_calls = {};
+
+ uint64_t bytes_transferred = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_storage_metrics_CallStatTable;
+
+struct CallStat {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_storage_metrics_CallStatTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::storage::metrics::CallStatRaw success = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStatRaw failure = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_storage_metrics_FsMetricsTable;
+
+struct FsMetrics {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_storage_metrics_FsMetricsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 640;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::storage::metrics::CallStat create = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat read = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat write = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat truncate = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat unlink = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat rename = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat lookup = {};
+
+ ::llcpp::fuchsia::storage::metrics::CallStat open = {};
+};
+
+} // namespace metrics
+} // namespace storage
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::storage::metrics::CallStatRaw> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::storage::metrics::CallStatRaw>);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::CallStatRaw, minimum_latency) == 0);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::CallStatRaw, maximum_latency) == 8);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::CallStatRaw, total_time_spent) == 16);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::CallStatRaw, total_calls) == 24);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::CallStatRaw, bytes_transferred) == 32);
+static_assert(sizeof(::llcpp::fuchsia::storage::metrics::CallStatRaw) == ::llcpp::fuchsia::storage::metrics::CallStatRaw::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::storage::metrics::CallStat> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::storage::metrics::CallStat>);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::CallStat, success) == 0);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::CallStat, failure) == 40);
+static_assert(sizeof(::llcpp::fuchsia::storage::metrics::CallStat) == ::llcpp::fuchsia::storage::metrics::CallStat::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::storage::metrics::FsMetrics> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::storage::metrics::FsMetrics>);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::FsMetrics, create) == 0);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::FsMetrics, read) == 80);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::FsMetrics, write) == 160);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::FsMetrics, truncate) == 240);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::FsMetrics, unlink) == 320);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::FsMetrics, rename) == 400);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::FsMetrics, lookup) == 480);
+static_assert(offsetof(::llcpp::fuchsia::storage::metrics::FsMetrics, open) == 560);
+static_assert(sizeof(::llcpp::fuchsia::storage::metrics::FsMetrics) == ::llcpp::fuchsia::storage::metrics::FsMetrics::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-sysinfo/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-sysinfo/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..eccb130
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-sysinfo/gen/llcpp/fidl.cc
@@ -0,0 +1,570 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/sysinfo/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace sysinfo {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kSysInfo_GetHypervisorResource_Ordinal = 0x4682e82d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSysInfo_GetHypervisorResource_GenOrdinal = 0x1ab9d2b80bbb43a4lu;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetHypervisorResourceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetHypervisorResourceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSysInfo_GetBoardName_Ordinal = 0x1346873400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSysInfo_GetBoardName_GenOrdinal = 0x6d29d1a6edf9a614lu;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetBoardNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetBoardNameResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSysInfo_GetBoardRevision_Ordinal = 0x6f07cacb00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSysInfo_GetBoardRevision_GenOrdinal = 0x3dd050d99012e9cclu;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetBoardRevisionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetBoardRevisionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSysInfo_GetInterruptControllerInfo_Ordinal = 0x4ff3937d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSysInfo_GetInterruptControllerInfo_GenOrdinal = 0x31a438b28dca119clu;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetInterruptControllerInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetInterruptControllerInfoResponseTable;
+
+} // namespace
+template <>
+SysInfo::ResultOf::GetHypervisorResource_Impl<SysInfo::GetHypervisorResourceResponse>::GetHypervisorResource_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetHypervisorResourceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetHypervisorResourceRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetHypervisorResourceRequest));
+ ::fidl::DecodedMessage<GetHypervisorResourceRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SysInfo::InPlace::GetHypervisorResource(std::move(_client_end), Super::response_buffer()));
+}
+
+SysInfo::ResultOf::GetHypervisorResource SysInfo::SyncClient::GetHypervisorResource() {
+ return ResultOf::GetHypervisorResource(::zx::unowned_channel(this->channel_));
+}
+
+SysInfo::ResultOf::GetHypervisorResource SysInfo::Call::GetHypervisorResource(::zx::unowned_channel _client_end) {
+ return ResultOf::GetHypervisorResource(std::move(_client_end));
+}
+
+template <>
+SysInfo::UnownedResultOf::GetHypervisorResource_Impl<SysInfo::GetHypervisorResourceResponse>::GetHypervisorResource_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetHypervisorResourceRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetHypervisorResourceRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetHypervisorResourceRequest));
+ ::fidl::DecodedMessage<GetHypervisorResourceRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SysInfo::InPlace::GetHypervisorResource(std::move(_client_end), std::move(_response_buffer)));
+}
+
+SysInfo::UnownedResultOf::GetHypervisorResource SysInfo::SyncClient::GetHypervisorResource(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetHypervisorResource(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+SysInfo::UnownedResultOf::GetHypervisorResource SysInfo::Call::GetHypervisorResource(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetHypervisorResource(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SysInfo::GetHypervisorResourceResponse> SysInfo::InPlace::GetHypervisorResource(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetHypervisorResourceRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetHypervisorResourceRequest> params(std::move(_request_buffer));
+ SysInfo::SetTransactionHeaderFor::GetHypervisorResourceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SysInfo::GetHypervisorResourceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetHypervisorResourceRequest, GetHypervisorResourceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SysInfo::GetHypervisorResourceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+SysInfo::ResultOf::GetBoardName_Impl<SysInfo::GetBoardNameResponse>::GetBoardName_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBoardNameRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetBoardNameRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBoardNameRequest));
+ ::fidl::DecodedMessage<GetBoardNameRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SysInfo::InPlace::GetBoardName(std::move(_client_end), Super::response_buffer()));
+}
+
+SysInfo::ResultOf::GetBoardName SysInfo::SyncClient::GetBoardName() {
+ return ResultOf::GetBoardName(::zx::unowned_channel(this->channel_));
+}
+
+SysInfo::ResultOf::GetBoardName SysInfo::Call::GetBoardName(::zx::unowned_channel _client_end) {
+ return ResultOf::GetBoardName(std::move(_client_end));
+}
+
+template <>
+SysInfo::UnownedResultOf::GetBoardName_Impl<SysInfo::GetBoardNameResponse>::GetBoardName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetBoardNameRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetBoardNameRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetBoardNameRequest));
+ ::fidl::DecodedMessage<GetBoardNameRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SysInfo::InPlace::GetBoardName(std::move(_client_end), std::move(_response_buffer)));
+}
+
+SysInfo::UnownedResultOf::GetBoardName SysInfo::SyncClient::GetBoardName(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBoardName(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+SysInfo::UnownedResultOf::GetBoardName SysInfo::Call::GetBoardName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBoardName(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SysInfo::GetBoardNameResponse> SysInfo::InPlace::GetBoardName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetBoardNameRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetBoardNameRequest> params(std::move(_request_buffer));
+ SysInfo::SetTransactionHeaderFor::GetBoardNameRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SysInfo::GetBoardNameResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetBoardNameRequest, GetBoardNameResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SysInfo::GetBoardNameResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+SysInfo::ResultOf::GetBoardRevision_Impl<SysInfo::GetBoardRevisionResponse>::GetBoardRevision_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBoardRevisionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetBoardRevisionRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBoardRevisionRequest));
+ ::fidl::DecodedMessage<GetBoardRevisionRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SysInfo::InPlace::GetBoardRevision(std::move(_client_end), Super::response_buffer()));
+}
+
+SysInfo::ResultOf::GetBoardRevision SysInfo::SyncClient::GetBoardRevision() {
+ return ResultOf::GetBoardRevision(::zx::unowned_channel(this->channel_));
+}
+
+SysInfo::ResultOf::GetBoardRevision SysInfo::Call::GetBoardRevision(::zx::unowned_channel _client_end) {
+ return ResultOf::GetBoardRevision(std::move(_client_end));
+}
+
+template <>
+SysInfo::UnownedResultOf::GetBoardRevision_Impl<SysInfo::GetBoardRevisionResponse>::GetBoardRevision_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetBoardRevisionRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetBoardRevisionRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetBoardRevisionRequest));
+ ::fidl::DecodedMessage<GetBoardRevisionRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SysInfo::InPlace::GetBoardRevision(std::move(_client_end), std::move(_response_buffer)));
+}
+
+SysInfo::UnownedResultOf::GetBoardRevision SysInfo::SyncClient::GetBoardRevision(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBoardRevision(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+SysInfo::UnownedResultOf::GetBoardRevision SysInfo::Call::GetBoardRevision(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetBoardRevision(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SysInfo::GetBoardRevisionResponse> SysInfo::InPlace::GetBoardRevision(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetBoardRevisionRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetBoardRevisionRequest> params(std::move(_request_buffer));
+ SysInfo::SetTransactionHeaderFor::GetBoardRevisionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SysInfo::GetBoardRevisionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetBoardRevisionRequest, GetBoardRevisionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SysInfo::GetBoardRevisionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+SysInfo::ResultOf::GetInterruptControllerInfo_Impl<SysInfo::GetInterruptControllerInfoResponse>::GetInterruptControllerInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInterruptControllerInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetInterruptControllerInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetInterruptControllerInfoRequest));
+ ::fidl::DecodedMessage<GetInterruptControllerInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SysInfo::InPlace::GetInterruptControllerInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+SysInfo::ResultOf::GetInterruptControllerInfo SysInfo::SyncClient::GetInterruptControllerInfo() {
+ return ResultOf::GetInterruptControllerInfo(::zx::unowned_channel(this->channel_));
+}
+
+SysInfo::ResultOf::GetInterruptControllerInfo SysInfo::Call::GetInterruptControllerInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetInterruptControllerInfo(std::move(_client_end));
+}
+
+template <>
+SysInfo::UnownedResultOf::GetInterruptControllerInfo_Impl<SysInfo::GetInterruptControllerInfoResponse>::GetInterruptControllerInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetInterruptControllerInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetInterruptControllerInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetInterruptControllerInfoRequest));
+ ::fidl::DecodedMessage<GetInterruptControllerInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SysInfo::InPlace::GetInterruptControllerInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+SysInfo::UnownedResultOf::GetInterruptControllerInfo SysInfo::SyncClient::GetInterruptControllerInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInterruptControllerInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+SysInfo::UnownedResultOf::GetInterruptControllerInfo SysInfo::Call::GetInterruptControllerInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetInterruptControllerInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SysInfo::GetInterruptControllerInfoResponse> SysInfo::InPlace::GetInterruptControllerInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetInterruptControllerInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetInterruptControllerInfoRequest> params(std::move(_request_buffer));
+ SysInfo::SetTransactionHeaderFor::GetInterruptControllerInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SysInfo::GetInterruptControllerInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetInterruptControllerInfoRequest, GetInterruptControllerInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SysInfo::GetInterruptControllerInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool SysInfo::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kSysInfo_GetHypervisorResource_Ordinal:
+ case kSysInfo_GetHypervisorResource_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetHypervisorResourceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetHypervisorResource(
+ Interface::GetHypervisorResourceCompleter::Sync(txn));
+ return true;
+ }
+ case kSysInfo_GetBoardName_Ordinal:
+ case kSysInfo_GetBoardName_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetBoardNameRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetBoardName(
+ Interface::GetBoardNameCompleter::Sync(txn));
+ return true;
+ }
+ case kSysInfo_GetBoardRevision_Ordinal:
+ case kSysInfo_GetBoardRevision_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetBoardRevisionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetBoardRevision(
+ Interface::GetBoardRevisionCompleter::Sync(txn));
+ return true;
+ }
+ case kSysInfo_GetInterruptControllerInfo_Ordinal:
+ case kSysInfo_GetInterruptControllerInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetInterruptControllerInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetInterruptControllerInfo(
+ Interface::GetInterruptControllerInfoCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool SysInfo::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void SysInfo::Interface::GetHypervisorResourceCompleterBase::Reply(int32_t status, ::zx::resource resource) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetHypervisorResourceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetHypervisorResourceResponse*>(_write_bytes);
+ SysInfo::SetTransactionHeaderFor::GetHypervisorResourceResponse(
+ ::fidl::DecodedMessage<GetHypervisorResourceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetHypervisorResourceResponse::PrimarySize,
+ GetHypervisorResourceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.resource = std::move(resource);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetHypervisorResourceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetHypervisorResourceResponse>(std::move(_response_bytes)));
+}
+
+void SysInfo::Interface::GetHypervisorResourceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::zx::resource resource) {
+ if (_buffer.capacity() < GetHypervisorResourceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetHypervisorResourceResponse*>(_buffer.data());
+ SysInfo::SetTransactionHeaderFor::GetHypervisorResourceResponse(
+ ::fidl::DecodedMessage<GetHypervisorResourceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetHypervisorResourceResponse::PrimarySize,
+ GetHypervisorResourceResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.resource = std::move(resource);
+ _buffer.set_actual(sizeof(GetHypervisorResourceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetHypervisorResourceResponse>(std::move(_buffer)));
+}
+
+void SysInfo::Interface::GetHypervisorResourceCompleterBase::Reply(::fidl::DecodedMessage<GetHypervisorResourceResponse> params) {
+ SysInfo::SetTransactionHeaderFor::GetHypervisorResourceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void SysInfo::Interface::GetBoardNameCompleterBase::Reply(int32_t status, ::fidl::StringView name) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBoardNameResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetBoardNameResponse _response = {};
+ SysInfo::SetTransactionHeaderFor::GetBoardNameResponse(
+ ::fidl::DecodedMessage<GetBoardNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBoardNameResponse::PrimarySize,
+ GetBoardNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void SysInfo::Interface::GetBoardNameCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::fidl::StringView name) {
+ if (_buffer.capacity() < GetBoardNameResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetBoardNameResponse _response = {};
+ SysInfo::SetTransactionHeaderFor::GetBoardNameResponse(
+ ::fidl::DecodedMessage<GetBoardNameResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBoardNameResponse::PrimarySize,
+ GetBoardNameResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.name = std::move(name);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void SysInfo::Interface::GetBoardNameCompleterBase::Reply(::fidl::DecodedMessage<GetBoardNameResponse> params) {
+ SysInfo::SetTransactionHeaderFor::GetBoardNameResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void SysInfo::Interface::GetBoardRevisionCompleterBase::Reply(int32_t status, uint32_t revision) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetBoardRevisionResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<GetBoardRevisionResponse*>(_write_bytes);
+ SysInfo::SetTransactionHeaderFor::GetBoardRevisionResponse(
+ ::fidl::DecodedMessage<GetBoardRevisionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBoardRevisionResponse::PrimarySize,
+ GetBoardRevisionResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.revision = std::move(revision);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetBoardRevisionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetBoardRevisionResponse>(std::move(_response_bytes)));
+}
+
+void SysInfo::Interface::GetBoardRevisionCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, uint32_t revision) {
+ if (_buffer.capacity() < GetBoardRevisionResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<GetBoardRevisionResponse*>(_buffer.data());
+ SysInfo::SetTransactionHeaderFor::GetBoardRevisionResponse(
+ ::fidl::DecodedMessage<GetBoardRevisionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetBoardRevisionResponse::PrimarySize,
+ GetBoardRevisionResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.revision = std::move(revision);
+ _buffer.set_actual(sizeof(GetBoardRevisionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<GetBoardRevisionResponse>(std::move(_buffer)));
+}
+
+void SysInfo::Interface::GetBoardRevisionCompleterBase::Reply(::fidl::DecodedMessage<GetBoardRevisionResponse> params) {
+ SysInfo::SetTransactionHeaderFor::GetBoardRevisionResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void SysInfo::Interface::GetInterruptControllerInfoCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::sysinfo::InterruptControllerInfo* info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetInterruptControllerInfoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ GetInterruptControllerInfoResponse _response = {};
+ SysInfo::SetTransactionHeaderFor::GetInterruptControllerInfoResponse(
+ ::fidl::DecodedMessage<GetInterruptControllerInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInterruptControllerInfoResponse::PrimarySize,
+ GetInterruptControllerInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void SysInfo::Interface::GetInterruptControllerInfoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::sysinfo::InterruptControllerInfo* info) {
+ if (_buffer.capacity() < GetInterruptControllerInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetInterruptControllerInfoResponse _response = {};
+ SysInfo::SetTransactionHeaderFor::GetInterruptControllerInfoResponse(
+ ::fidl::DecodedMessage<GetInterruptControllerInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetInterruptControllerInfoResponse::PrimarySize,
+ GetInterruptControllerInfoResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void SysInfo::Interface::GetInterruptControllerInfoCompleterBase::Reply(::fidl::DecodedMessage<GetInterruptControllerInfoResponse> params) {
+ SysInfo::SetTransactionHeaderFor::GetInterruptControllerInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void SysInfo::SetTransactionHeaderFor::GetHypervisorResourceRequest(const ::fidl::DecodedMessage<SysInfo::GetHypervisorResourceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSysInfo_GetHypervisorResource_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SysInfo::SetTransactionHeaderFor::GetHypervisorResourceResponse(const ::fidl::DecodedMessage<SysInfo::GetHypervisorResourceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSysInfo_GetHypervisorResource_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void SysInfo::SetTransactionHeaderFor::GetBoardNameRequest(const ::fidl::DecodedMessage<SysInfo::GetBoardNameRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSysInfo_GetBoardName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SysInfo::SetTransactionHeaderFor::GetBoardNameResponse(const ::fidl::DecodedMessage<SysInfo::GetBoardNameResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSysInfo_GetBoardName_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void SysInfo::SetTransactionHeaderFor::GetBoardRevisionRequest(const ::fidl::DecodedMessage<SysInfo::GetBoardRevisionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSysInfo_GetBoardRevision_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SysInfo::SetTransactionHeaderFor::GetBoardRevisionResponse(const ::fidl::DecodedMessage<SysInfo::GetBoardRevisionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSysInfo_GetBoardRevision_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void SysInfo::SetTransactionHeaderFor::GetInterruptControllerInfoRequest(const ::fidl::DecodedMessage<SysInfo::GetInterruptControllerInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSysInfo_GetInterruptControllerInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SysInfo::SetTransactionHeaderFor::GetInterruptControllerInfoResponse(const ::fidl::DecodedMessage<SysInfo::GetInterruptControllerInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSysInfo_GetInterruptControllerInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace sysinfo
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-sysinfo/gen/llcpp/include/fuchsia/sysinfo/llcpp/fidl.h b/zircon/system/fidl/fuchsia-sysinfo/gen/llcpp/include/fuchsia/sysinfo/llcpp/fidl.h
new file mode 100644
index 0000000..60bfe67
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-sysinfo/gen/llcpp/include/fuchsia/sysinfo/llcpp/fidl.h
@@ -0,0 +1,541 @@
+// 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/resource.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace sysinfo {
+
+class SysInfo;
+enum class InterruptControllerType : uint32_t {
+ UNKNOWN = 0u,
+ APIC = 1u,
+ GIC_V2 = 2u,
+ GIC_V3 = 3u,
+};
+
+
+struct InterruptControllerInfo;
+
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetHypervisorResourceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetHypervisorResourceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetBoardNameRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetBoardNameResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetBoardRevisionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetBoardRevisionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetInterruptControllerInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_SysInfoGetInterruptControllerInfoResponseTable;
+
+class SysInfo final {
+ SysInfo() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.sysinfo.SysInfo";
+
+ struct GetHypervisorResourceResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::zx::resource resource;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysinfo_SysInfoGetHypervisorResourceResponseTable;
+ 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 GetHypervisorResourceRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetBoardNameResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::fidl::StringView name;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysinfo_SysInfoGetBoardNameResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ 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 GetBoardNameRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetBoardRevisionResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ uint32_t revision;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysinfo_SysInfoGetBoardRevisionResponseTable;
+ 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 GetBoardRevisionRequest = ::fidl::AnyZeroArgMessage;
+
+ struct GetInterruptControllerInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::sysinfo::InterruptControllerInfo* info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysinfo_SysInfoGetInterruptControllerInfoResponseTable;
+ 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;
+ };
+ using GetInterruptControllerInfoRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetHypervisorResource_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetHypervisorResource_Impl(::zx::unowned_channel _client_end);
+ ~GetHypervisorResource_Impl() = default;
+ GetHypervisorResource_Impl(GetHypervisorResource_Impl&& other) = default;
+ GetHypervisorResource_Impl& operator=(GetHypervisorResource_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 GetBoardName_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetBoardName_Impl(::zx::unowned_channel _client_end);
+ ~GetBoardName_Impl() = default;
+ GetBoardName_Impl(GetBoardName_Impl&& other) = default;
+ GetBoardName_Impl& operator=(GetBoardName_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 GetBoardRevision_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetBoardRevision_Impl(::zx::unowned_channel _client_end);
+ ~GetBoardRevision_Impl() = default;
+ GetBoardRevision_Impl(GetBoardRevision_Impl&& other) = default;
+ GetBoardRevision_Impl& operator=(GetBoardRevision_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 GetInterruptControllerInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetInterruptControllerInfo_Impl(::zx::unowned_channel _client_end);
+ ~GetInterruptControllerInfo_Impl() = default;
+ GetInterruptControllerInfo_Impl(GetInterruptControllerInfo_Impl&& other) = default;
+ GetInterruptControllerInfo_Impl& operator=(GetInterruptControllerInfo_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 GetHypervisorResource = GetHypervisorResource_Impl<GetHypervisorResourceResponse>;
+ using GetBoardName = GetBoardName_Impl<GetBoardNameResponse>;
+ using GetBoardRevision = GetBoardRevision_Impl<GetBoardRevisionResponse>;
+ using GetInterruptControllerInfo = GetInterruptControllerInfo_Impl<GetInterruptControllerInfoResponse>;
+ };
+
+ // 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 GetHypervisorResource_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetHypervisorResource_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetHypervisorResource_Impl() = default;
+ GetHypervisorResource_Impl(GetHypervisorResource_Impl&& other) = default;
+ GetHypervisorResource_Impl& operator=(GetHypervisorResource_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 GetBoardName_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetBoardName_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetBoardName_Impl() = default;
+ GetBoardName_Impl(GetBoardName_Impl&& other) = default;
+ GetBoardName_Impl& operator=(GetBoardName_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 GetBoardRevision_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetBoardRevision_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetBoardRevision_Impl() = default;
+ GetBoardRevision_Impl(GetBoardRevision_Impl&& other) = default;
+ GetBoardRevision_Impl& operator=(GetBoardRevision_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 GetInterruptControllerInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetInterruptControllerInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetInterruptControllerInfo_Impl() = default;
+ GetInterruptControllerInfo_Impl(GetInterruptControllerInfo_Impl&& other) = default;
+ GetInterruptControllerInfo_Impl& operator=(GetInterruptControllerInfo_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 GetHypervisorResource = GetHypervisorResource_Impl<GetHypervisorResourceResponse>;
+ using GetBoardName = GetBoardName_Impl<GetBoardNameResponse>;
+ using GetBoardRevision = GetBoardRevision_Impl<GetBoardRevisionResponse>;
+ using GetInterruptControllerInfo = GetInterruptControllerInfo_Impl<GetInterruptControllerInfoResponse>;
+ };
+
+ 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_; }
+
+ // Return the hypervisor resource (with only ZX_RIGHT_TRANSFER).
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetHypervisorResource GetHypervisorResource();
+
+ // Return the hypervisor resource (with only ZX_RIGHT_TRANSFER).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetHypervisorResource GetHypervisorResource(::fidl::BytePart _response_buffer);
+
+ // Return the board name for the platform we are running on.
+ // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetBoardName GetBoardName();
+
+ // Return the board name for the platform we are running on.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetBoardName GetBoardName(::fidl::BytePart _response_buffer);
+
+ // Return the board revision for the board we are running on.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetBoardRevision GetBoardRevision();
+
+ // Return the board revision for the board we are running on.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetBoardRevision GetBoardRevision(::fidl::BytePart _response_buffer);
+
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::GetInterruptControllerInfo GetInterruptControllerInfo();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetInterruptControllerInfo GetInterruptControllerInfo(::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:
+
+ // Return the hypervisor resource (with only ZX_RIGHT_TRANSFER).
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetHypervisorResource GetHypervisorResource(::zx::unowned_channel _client_end);
+
+ // Return the hypervisor resource (with only ZX_RIGHT_TRANSFER).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetHypervisorResource GetHypervisorResource(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Return the board name for the platform we are running on.
+ // Allocates 88 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetBoardName GetBoardName(::zx::unowned_channel _client_end);
+
+ // Return the board name for the platform we are running on.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetBoardName GetBoardName(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Return the board revision for the board we are running on.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetBoardRevision GetBoardRevision(::zx::unowned_channel _client_end);
+
+ // Return the board revision for the board we are running on.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetBoardRevision GetBoardRevision(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::GetInterruptControllerInfo GetInterruptControllerInfo(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetInterruptControllerInfo GetInterruptControllerInfo(::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:
+
+ // Return the hypervisor resource (with only ZX_RIGHT_TRANSFER).
+ static ::fidl::DecodeResult<GetHypervisorResourceResponse> GetHypervisorResource(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return the board name for the platform we are running on.
+ static ::fidl::DecodeResult<GetBoardNameResponse> GetBoardName(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Return the board revision for the board we are running on.
+ static ::fidl::DecodeResult<GetBoardRevisionResponse> GetBoardRevision(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ static ::fidl::DecodeResult<GetInterruptControllerInfoResponse> GetInterruptControllerInfo(::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 = SysInfo;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetHypervisorResourceCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::zx::resource resource);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::zx::resource resource);
+ void Reply(::fidl::DecodedMessage<GetHypervisorResourceResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetHypervisorResourceCompleter = ::fidl::Completer<GetHypervisorResourceCompleterBase>;
+
+ virtual void GetHypervisorResource(GetHypervisorResourceCompleter::Sync _completer) = 0;
+
+ class GetBoardNameCompleterBase : 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<GetBoardNameResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetBoardNameCompleter = ::fidl::Completer<GetBoardNameCompleterBase>;
+
+ virtual void GetBoardName(GetBoardNameCompleter::Sync _completer) = 0;
+
+ class GetBoardRevisionCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, uint32_t revision);
+ void Reply(::fidl::BytePart _buffer, int32_t status, uint32_t revision);
+ void Reply(::fidl::DecodedMessage<GetBoardRevisionResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetBoardRevisionCompleter = ::fidl::Completer<GetBoardRevisionCompleterBase>;
+
+ virtual void GetBoardRevision(GetBoardRevisionCompleter::Sync _completer) { _completer.Close(ZX_ERR_NOT_SUPPORTED); }
+
+ class GetInterruptControllerInfoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::sysinfo::InterruptControllerInfo* info);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::sysinfo::InterruptControllerInfo* info);
+ void Reply(::fidl::DecodedMessage<GetInterruptControllerInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetInterruptControllerInfoCompleter = ::fidl::Completer<GetInterruptControllerInfoCompleterBase>;
+
+ virtual void GetInterruptControllerInfo(GetInterruptControllerInfoCompleter::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 GetHypervisorResourceRequest(const ::fidl::DecodedMessage<SysInfo::GetHypervisorResourceRequest>& _msg);
+ static void GetHypervisorResourceResponse(const ::fidl::DecodedMessage<SysInfo::GetHypervisorResourceResponse>& _msg);
+ static void GetBoardNameRequest(const ::fidl::DecodedMessage<SysInfo::GetBoardNameRequest>& _msg);
+ static void GetBoardNameResponse(const ::fidl::DecodedMessage<SysInfo::GetBoardNameResponse>& _msg);
+ static void GetBoardRevisionRequest(const ::fidl::DecodedMessage<SysInfo::GetBoardRevisionRequest>& _msg);
+ static void GetBoardRevisionResponse(const ::fidl::DecodedMessage<SysInfo::GetBoardRevisionResponse>& _msg);
+ static void GetInterruptControllerInfoRequest(const ::fidl::DecodedMessage<SysInfo::GetInterruptControllerInfoRequest>& _msg);
+ static void GetInterruptControllerInfoResponse(const ::fidl::DecodedMessage<SysInfo::GetInterruptControllerInfoResponse>& _msg);
+ };
+};
+
+constexpr uint8_t SYSINFO_BOARD_NAME_LEN = 32u;
+
+extern "C" const fidl_type_t v1_fuchsia_sysinfo_InterruptControllerInfoTable;
+
+struct InterruptControllerInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysinfo_InterruptControllerInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::sysinfo::InterruptControllerType type = {};
+};
+
+} // namespace sysinfo
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysinfo::SysInfo::GetHypervisorResourceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysinfo::SysInfo::GetHypervisorResourceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysinfo::SysInfo::GetHypervisorResourceResponse)
+ == ::llcpp::fuchsia::sysinfo::SysInfo::GetHypervisorResourceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::SysInfo::GetHypervisorResourceResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::SysInfo::GetHypervisorResourceResponse, resource) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysinfo::SysInfo::GetBoardNameResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysinfo::SysInfo::GetBoardNameResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysinfo::SysInfo::GetBoardNameResponse)
+ == ::llcpp::fuchsia::sysinfo::SysInfo::GetBoardNameResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::SysInfo::GetBoardNameResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::SysInfo::GetBoardNameResponse, name) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysinfo::SysInfo::GetBoardRevisionResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysinfo::SysInfo::GetBoardRevisionResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysinfo::SysInfo::GetBoardRevisionResponse)
+ == ::llcpp::fuchsia::sysinfo::SysInfo::GetBoardRevisionResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::SysInfo::GetBoardRevisionResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::SysInfo::GetBoardRevisionResponse, revision) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysinfo::SysInfo::GetInterruptControllerInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysinfo::SysInfo::GetInterruptControllerInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysinfo::SysInfo::GetInterruptControllerInfoResponse)
+ == ::llcpp::fuchsia::sysinfo::SysInfo::GetInterruptControllerInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::SysInfo::GetInterruptControllerInfoResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::SysInfo::GetInterruptControllerInfoResponse, info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysinfo::InterruptControllerInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysinfo::InterruptControllerInfo>);
+static_assert(offsetof(::llcpp::fuchsia::sysinfo::InterruptControllerInfo, type) == 0);
+static_assert(sizeof(::llcpp::fuchsia::sysinfo::InterruptControllerInfo) == ::llcpp::fuchsia::sysinfo::InterruptControllerInfo::PrimarySize);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-sysmem/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-sysmem/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..35d3a8b
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-sysmem/gen/llcpp/fidl.cc
@@ -0,0 +1,2721 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/sysmem/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace sysmem {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionToken_Duplicate_Ordinal = 0x5e37401300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionToken_Duplicate_GenOrdinal = 0x2f9f81bdde4b7292lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenDuplicateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenDuplicateResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionToken_Sync_Ordinal = 0x3218cf6000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionToken_Sync_GenOrdinal = 0x16941ac71d960cd0lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionToken_Close_Ordinal = 0x21ba753500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionToken_Close_GenOrdinal = 0x11df1970c2c12176lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenCloseResponseTable;
+
+} // namespace
+
+BufferCollectionToken::ResultOf::Duplicate_Impl::Duplicate_Impl(::zx::unowned_channel _client_end, uint32_t rights_attenuation_mask, ::zx::channel token_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DuplicateRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DuplicateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DuplicateRequest*>(_write_bytes);
+ _request.rights_attenuation_mask = std::move(rights_attenuation_mask);
+ _request.token_request = std::move(token_request);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DuplicateRequest));
+ ::fidl::DecodedMessage<DuplicateRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollectionToken::InPlace::Duplicate(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollectionToken::ResultOf::Duplicate BufferCollectionToken::SyncClient::Duplicate(uint32_t rights_attenuation_mask, ::zx::channel token_request) {
+ return ResultOf::Duplicate(::zx::unowned_channel(this->channel_), std::move(rights_attenuation_mask), std::move(token_request));
+}
+
+BufferCollectionToken::ResultOf::Duplicate BufferCollectionToken::Call::Duplicate(::zx::unowned_channel _client_end, uint32_t rights_attenuation_mask, ::zx::channel token_request) {
+ return ResultOf::Duplicate(std::move(_client_end), std::move(rights_attenuation_mask), std::move(token_request));
+}
+
+
+BufferCollectionToken::UnownedResultOf::Duplicate_Impl::Duplicate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t rights_attenuation_mask, ::zx::channel token_request) {
+ if (_request_buffer.capacity() < DuplicateRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, DuplicateRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DuplicateRequest*>(_request_buffer.data());
+ _request.rights_attenuation_mask = std::move(rights_attenuation_mask);
+ _request.token_request = std::move(token_request);
+ _request_buffer.set_actual(sizeof(DuplicateRequest));
+ ::fidl::DecodedMessage<DuplicateRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BufferCollectionToken::InPlace::Duplicate(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollectionToken::UnownedResultOf::Duplicate BufferCollectionToken::SyncClient::Duplicate(::fidl::BytePart _request_buffer, uint32_t rights_attenuation_mask, ::zx::channel token_request) {
+ return UnownedResultOf::Duplicate(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(rights_attenuation_mask), std::move(token_request));
+}
+
+BufferCollectionToken::UnownedResultOf::Duplicate BufferCollectionToken::Call::Duplicate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t rights_attenuation_mask, ::zx::channel token_request) {
+ return UnownedResultOf::Duplicate(std::move(_client_end), std::move(_request_buffer), std::move(rights_attenuation_mask), std::move(token_request));
+}
+
+::fidl::internal::StatusAndError BufferCollectionToken::InPlace::Duplicate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DuplicateRequest> params) {
+ BufferCollectionToken::SetTransactionHeaderFor::DuplicateRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+BufferCollectionToken::ResultOf::Sync_Impl<BufferCollectionToken::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BufferCollectionToken::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+BufferCollectionToken::ResultOf::Sync BufferCollectionToken::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+BufferCollectionToken::ResultOf::Sync BufferCollectionToken::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+::fidl::DecodeResult<BufferCollectionToken::SyncResponse> BufferCollectionToken::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ BufferCollectionToken::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollectionToken::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollectionToken::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+BufferCollectionToken::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollectionToken::InPlace::Close(std::move(_client_end)));
+}
+
+BufferCollectionToken::ResultOf::Close BufferCollectionToken::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+BufferCollectionToken::ResultOf::Close BufferCollectionToken::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError BufferCollectionToken::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ BufferCollectionToken::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool BufferCollectionToken::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBufferCollectionToken_Duplicate_Ordinal:
+ case kBufferCollectionToken_Duplicate_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DuplicateRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Duplicate(std::move(message->rights_attenuation_mask), std::move(message->token_request),
+ Interface::DuplicateCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollectionToken_Sync_Ordinal:
+ case kBufferCollectionToken_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollectionToken_Close_Ordinal:
+ case kBufferCollectionToken_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool BufferCollectionToken::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void BufferCollectionToken::Interface::SyncCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ BufferCollectionToken::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+
+
+void BufferCollectionToken::SetTransactionHeaderFor::DuplicateRequest(const ::fidl::DecodedMessage<BufferCollectionToken::DuplicateRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollectionToken_Duplicate_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollectionToken::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<BufferCollectionToken::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollectionToken_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BufferCollectionToken::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<BufferCollectionToken::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollectionToken_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollectionToken::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<BufferCollectionToken::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollectionToken_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kHeap_AllocateVmo_Ordinal = 0xbb99f8d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kHeap_AllocateVmo_GenOrdinal = 0x1c885a457f626eeflu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapAllocateVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapAllocateVmoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kHeap_CreateResource_Ordinal = 0x35a990c200000000lu;
+[[maybe_unused]]
+constexpr uint64_t kHeap_CreateResource_GenOrdinal = 0x20f4e8b60cb76063lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapCreateResourceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapCreateResourceResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kHeap_DestroyResource_Ordinal = 0x27df37a100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kHeap_DestroyResource_GenOrdinal = 0x766bee03db72e8falu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapDestroyResourceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapDestroyResourceResponseTable;
+
+} // namespace
+template <>
+Heap::ResultOf::AllocateVmo_Impl<Heap::AllocateVmoResponse>::AllocateVmo_Impl(::zx::unowned_channel _client_end, uint64_t size) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocateVmoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AllocateVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateVmoRequest*>(_write_bytes);
+ _request.size = std::move(size);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AllocateVmoRequest));
+ ::fidl::DecodedMessage<AllocateVmoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Heap::InPlace::AllocateVmo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Heap::ResultOf::AllocateVmo Heap::SyncClient::AllocateVmo(uint64_t size) {
+ return ResultOf::AllocateVmo(::zx::unowned_channel(this->channel_), std::move(size));
+}
+
+Heap::ResultOf::AllocateVmo Heap::Call::AllocateVmo(::zx::unowned_channel _client_end, uint64_t size) {
+ return ResultOf::AllocateVmo(std::move(_client_end), std::move(size));
+}
+
+template <>
+Heap::UnownedResultOf::AllocateVmo_Impl<Heap::AllocateVmoResponse>::AllocateVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t size, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < AllocateVmoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<AllocateVmoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, AllocateVmoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateVmoRequest*>(_request_buffer.data());
+ _request.size = std::move(size);
+ _request_buffer.set_actual(sizeof(AllocateVmoRequest));
+ ::fidl::DecodedMessage<AllocateVmoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Heap::InPlace::AllocateVmo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Heap::UnownedResultOf::AllocateVmo Heap::SyncClient::AllocateVmo(::fidl::BytePart _request_buffer, uint64_t size, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AllocateVmo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(size), std::move(_response_buffer));
+}
+
+Heap::UnownedResultOf::AllocateVmo Heap::Call::AllocateVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t size, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::AllocateVmo(std::move(_client_end), std::move(_request_buffer), std::move(size), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Heap::AllocateVmoResponse> Heap::InPlace::AllocateVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateVmoRequest> params, ::fidl::BytePart response_buffer) {
+ Heap::SetTransactionHeaderFor::AllocateVmoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Heap::AllocateVmoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<AllocateVmoRequest, AllocateVmoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Heap::AllocateVmoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Heap::ResultOf::CreateResource_Impl<Heap::CreateResourceResponse>::CreateResource_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateResourceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CreateResourceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateResourceRequest*>(_write_bytes);
+ _request.vmo = std::move(vmo);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateResourceRequest));
+ ::fidl::DecodedMessage<CreateResourceRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Heap::InPlace::CreateResource(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Heap::ResultOf::CreateResource Heap::SyncClient::CreateResource(::zx::vmo vmo) {
+ return ResultOf::CreateResource(::zx::unowned_channel(this->channel_), std::move(vmo));
+}
+
+Heap::ResultOf::CreateResource Heap::Call::CreateResource(::zx::unowned_channel _client_end, ::zx::vmo vmo) {
+ return ResultOf::CreateResource(std::move(_client_end), std::move(vmo));
+}
+
+template <>
+Heap::UnownedResultOf::CreateResource_Impl<Heap::CreateResourceResponse>::CreateResource_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CreateResourceRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CreateResourceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CreateResourceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CreateResourceRequest*>(_request_buffer.data());
+ _request.vmo = std::move(vmo);
+ _request_buffer.set_actual(sizeof(CreateResourceRequest));
+ ::fidl::DecodedMessage<CreateResourceRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Heap::InPlace::CreateResource(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Heap::UnownedResultOf::CreateResource Heap::SyncClient::CreateResource(::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateResource(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+Heap::UnownedResultOf::CreateResource Heap::Call::CreateResource(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CreateResource(std::move(_client_end), std::move(_request_buffer), std::move(vmo), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Heap::CreateResourceResponse> Heap::InPlace::CreateResource(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateResourceRequest> params, ::fidl::BytePart response_buffer) {
+ Heap::SetTransactionHeaderFor::CreateResourceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Heap::CreateResourceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CreateResourceRequest, CreateResourceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Heap::CreateResourceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Heap::ResultOf::DestroyResource_Impl<Heap::DestroyResourceResponse>::DestroyResource_Impl(::zx::unowned_channel _client_end, uint64_t id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DestroyResourceRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, DestroyResourceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DestroyResourceRequest*>(_write_bytes);
+ _request.id = std::move(id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(DestroyResourceRequest));
+ ::fidl::DecodedMessage<DestroyResourceRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Heap::InPlace::DestroyResource(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Heap::ResultOf::DestroyResource Heap::SyncClient::DestroyResource(uint64_t id) {
+ return ResultOf::DestroyResource(::zx::unowned_channel(this->channel_), std::move(id));
+}
+
+Heap::ResultOf::DestroyResource Heap::Call::DestroyResource(::zx::unowned_channel _client_end, uint64_t id) {
+ return ResultOf::DestroyResource(std::move(_client_end), std::move(id));
+}
+
+template <>
+Heap::UnownedResultOf::DestroyResource_Impl<Heap::DestroyResourceResponse>::DestroyResource_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < DestroyResourceRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<DestroyResourceResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, DestroyResourceRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<DestroyResourceRequest*>(_request_buffer.data());
+ _request.id = std::move(id);
+ _request_buffer.set_actual(sizeof(DestroyResourceRequest));
+ ::fidl::DecodedMessage<DestroyResourceRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Heap::InPlace::DestroyResource(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Heap::UnownedResultOf::DestroyResource Heap::SyncClient::DestroyResource(::fidl::BytePart _request_buffer, uint64_t id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DestroyResource(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(id), std::move(_response_buffer));
+}
+
+Heap::UnownedResultOf::DestroyResource Heap::Call::DestroyResource(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::DestroyResource(std::move(_client_end), std::move(_request_buffer), std::move(id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Heap::DestroyResourceResponse> Heap::InPlace::DestroyResource(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DestroyResourceRequest> params, ::fidl::BytePart response_buffer) {
+ Heap::SetTransactionHeaderFor::DestroyResourceRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Heap::DestroyResourceResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<DestroyResourceRequest, DestroyResourceResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Heap::DestroyResourceResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Heap::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kHeap_AllocateVmo_Ordinal:
+ case kHeap_AllocateVmo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AllocateVmoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AllocateVmo(std::move(message->size),
+ Interface::AllocateVmoCompleter::Sync(txn));
+ return true;
+ }
+ case kHeap_CreateResource_Ordinal:
+ case kHeap_CreateResource_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CreateResourceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CreateResource(std::move(message->vmo),
+ Interface::CreateResourceCompleter::Sync(txn));
+ return true;
+ }
+ case kHeap_DestroyResource_Ordinal:
+ case kHeap_DestroyResource_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<DestroyResourceRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->DestroyResource(std::move(message->id),
+ Interface::DestroyResourceCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Heap::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Heap::Interface::AllocateVmoCompleterBase::Reply(int32_t s, ::zx::vmo vmo) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocateVmoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<AllocateVmoResponse*>(_write_bytes);
+ Heap::SetTransactionHeaderFor::AllocateVmoResponse(
+ ::fidl::DecodedMessage<AllocateVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AllocateVmoResponse::PrimarySize,
+ AllocateVmoResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.vmo = std::move(vmo);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(AllocateVmoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<AllocateVmoResponse>(std::move(_response_bytes)));
+}
+
+void Heap::Interface::AllocateVmoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, ::zx::vmo vmo) {
+ if (_buffer.capacity() < AllocateVmoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<AllocateVmoResponse*>(_buffer.data());
+ Heap::SetTransactionHeaderFor::AllocateVmoResponse(
+ ::fidl::DecodedMessage<AllocateVmoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ AllocateVmoResponse::PrimarySize,
+ AllocateVmoResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.vmo = std::move(vmo);
+ _buffer.set_actual(sizeof(AllocateVmoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<AllocateVmoResponse>(std::move(_buffer)));
+}
+
+void Heap::Interface::AllocateVmoCompleterBase::Reply(::fidl::DecodedMessage<AllocateVmoResponse> params) {
+ Heap::SetTransactionHeaderFor::AllocateVmoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Heap::Interface::CreateResourceCompleterBase::Reply(int32_t s, uint64_t id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CreateResourceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CreateResourceResponse*>(_write_bytes);
+ Heap::SetTransactionHeaderFor::CreateResourceResponse(
+ ::fidl::DecodedMessage<CreateResourceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateResourceResponse::PrimarySize,
+ CreateResourceResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.id = std::move(id);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CreateResourceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateResourceResponse>(std::move(_response_bytes)));
+}
+
+void Heap::Interface::CreateResourceCompleterBase::Reply(::fidl::BytePart _buffer, int32_t s, uint64_t id) {
+ if (_buffer.capacity() < CreateResourceResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CreateResourceResponse*>(_buffer.data());
+ Heap::SetTransactionHeaderFor::CreateResourceResponse(
+ ::fidl::DecodedMessage<CreateResourceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CreateResourceResponse::PrimarySize,
+ CreateResourceResponse::PrimarySize)));
+ _response.s = std::move(s);
+ _response.id = std::move(id);
+ _buffer.set_actual(sizeof(CreateResourceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CreateResourceResponse>(std::move(_buffer)));
+}
+
+void Heap::Interface::CreateResourceCompleterBase::Reply(::fidl::DecodedMessage<CreateResourceResponse> params) {
+ Heap::SetTransactionHeaderFor::CreateResourceResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Heap::Interface::DestroyResourceCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<DestroyResourceResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<DestroyResourceResponse*>(_write_bytes);
+ Heap::SetTransactionHeaderFor::DestroyResourceResponse(
+ ::fidl::DecodedMessage<DestroyResourceResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ DestroyResourceResponse::PrimarySize,
+ DestroyResourceResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(DestroyResourceResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<DestroyResourceResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Heap::SetTransactionHeaderFor::AllocateVmoRequest(const ::fidl::DecodedMessage<Heap::AllocateVmoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kHeap_AllocateVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Heap::SetTransactionHeaderFor::AllocateVmoResponse(const ::fidl::DecodedMessage<Heap::AllocateVmoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kHeap_AllocateVmo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Heap::SetTransactionHeaderFor::CreateResourceRequest(const ::fidl::DecodedMessage<Heap::CreateResourceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kHeap_CreateResource_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Heap::SetTransactionHeaderFor::CreateResourceResponse(const ::fidl::DecodedMessage<Heap::CreateResourceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kHeap_CreateResource_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Heap::SetTransactionHeaderFor::DestroyResourceRequest(const ::fidl::DecodedMessage<Heap::DestroyResourceRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kHeap_DestroyResource_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Heap::SetTransactionHeaderFor::DestroyResourceResponse(const ::fidl::DecodedMessage<Heap::DestroyResourceResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kHeap_DestroyResource_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDriverConnector_Connect_Ordinal = 0x3082e03400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDriverConnector_Connect_GenOrdinal = 0x663a49f8408b8184lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_DriverConnectorConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_DriverConnectorConnectResponseTable;
+
+} // namespace
+
+DriverConnector::ResultOf::Connect_Impl::Connect_Impl(::zx::unowned_channel _client_end, ::zx::channel allocator_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConnectRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConnectRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConnectRequest*>(_write_bytes);
+ _request.allocator_request = std::move(allocator_request);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConnectRequest));
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ DriverConnector::InPlace::Connect(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DriverConnector::ResultOf::Connect DriverConnector::SyncClient::Connect(::zx::channel allocator_request) {
+ return ResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(allocator_request));
+}
+
+DriverConnector::ResultOf::Connect DriverConnector::Call::Connect(::zx::unowned_channel _client_end, ::zx::channel allocator_request) {
+ return ResultOf::Connect(std::move(_client_end), std::move(allocator_request));
+}
+
+
+DriverConnector::UnownedResultOf::Connect_Impl::Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel allocator_request) {
+ if (_request_buffer.capacity() < ConnectRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, ConnectRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConnectRequest*>(_request_buffer.data());
+ _request.allocator_request = std::move(allocator_request);
+ _request_buffer.set_actual(sizeof(ConnectRequest));
+ ::fidl::DecodedMessage<ConnectRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ DriverConnector::InPlace::Connect(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DriverConnector::UnownedResultOf::Connect DriverConnector::SyncClient::Connect(::fidl::BytePart _request_buffer, ::zx::channel allocator_request) {
+ return UnownedResultOf::Connect(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(allocator_request));
+}
+
+DriverConnector::UnownedResultOf::Connect DriverConnector::Call::Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel allocator_request) {
+ return UnownedResultOf::Connect(std::move(_client_end), std::move(_request_buffer), std::move(allocator_request));
+}
+
+::fidl::internal::StatusAndError DriverConnector::InPlace::Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params) {
+ DriverConnector::SetTransactionHeaderFor::ConnectRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool DriverConnector::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDriverConnector_Connect_Ordinal:
+ case kDriverConnector_Connect_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConnectRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Connect(std::move(message->allocator_request),
+ Interface::ConnectCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DriverConnector::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void DriverConnector::SetTransactionHeaderFor::ConnectRequest(const ::fidl::DecodedMessage<DriverConnector::ConnectRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDriverConnector_Connect_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kAllocator_AllocateNonSharedCollection_Ordinal = 0x21b157d700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kAllocator_AllocateNonSharedCollection_GenOrdinal = 0x20f79299bbb4d2c6lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorAllocateNonSharedCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorAllocateNonSharedCollectionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kAllocator_AllocateSharedCollection_Ordinal = 0x36a4dbc400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kAllocator_AllocateSharedCollection_GenOrdinal = 0x7a757a57bfda0f71lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorAllocateSharedCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorAllocateSharedCollectionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kAllocator_BindSharedCollection_Ordinal = 0x1d68697500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kAllocator_BindSharedCollection_GenOrdinal = 0x146eca7ec46ff4eelu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorBindSharedCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorBindSharedCollectionResponseTable;
+
+} // namespace
+
+Allocator::ResultOf::AllocateNonSharedCollection_Impl::AllocateNonSharedCollection_Impl(::zx::unowned_channel _client_end, ::zx::channel collection) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocateNonSharedCollectionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AllocateNonSharedCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateNonSharedCollectionRequest*>(_write_bytes);
+ _request.collection = std::move(collection);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AllocateNonSharedCollectionRequest));
+ ::fidl::DecodedMessage<AllocateNonSharedCollectionRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Allocator::InPlace::AllocateNonSharedCollection(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Allocator::ResultOf::AllocateNonSharedCollection Allocator::SyncClient::AllocateNonSharedCollection(::zx::channel collection) {
+ return ResultOf::AllocateNonSharedCollection(::zx::unowned_channel(this->channel_), std::move(collection));
+}
+
+Allocator::ResultOf::AllocateNonSharedCollection Allocator::Call::AllocateNonSharedCollection(::zx::unowned_channel _client_end, ::zx::channel collection) {
+ return ResultOf::AllocateNonSharedCollection(std::move(_client_end), std::move(collection));
+}
+
+
+Allocator::UnownedResultOf::AllocateNonSharedCollection_Impl::AllocateNonSharedCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel collection) {
+ if (_request_buffer.capacity() < AllocateNonSharedCollectionRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, AllocateNonSharedCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateNonSharedCollectionRequest*>(_request_buffer.data());
+ _request.collection = std::move(collection);
+ _request_buffer.set_actual(sizeof(AllocateNonSharedCollectionRequest));
+ ::fidl::DecodedMessage<AllocateNonSharedCollectionRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Allocator::InPlace::AllocateNonSharedCollection(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Allocator::UnownedResultOf::AllocateNonSharedCollection Allocator::SyncClient::AllocateNonSharedCollection(::fidl::BytePart _request_buffer, ::zx::channel collection) {
+ return UnownedResultOf::AllocateNonSharedCollection(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(collection));
+}
+
+Allocator::UnownedResultOf::AllocateNonSharedCollection Allocator::Call::AllocateNonSharedCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel collection) {
+ return UnownedResultOf::AllocateNonSharedCollection(std::move(_client_end), std::move(_request_buffer), std::move(collection));
+}
+
+::fidl::internal::StatusAndError Allocator::InPlace::AllocateNonSharedCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateNonSharedCollectionRequest> params) {
+ Allocator::SetTransactionHeaderFor::AllocateNonSharedCollectionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Allocator::ResultOf::AllocateSharedCollection_Impl::AllocateSharedCollection_Impl(::zx::unowned_channel _client_end, ::zx::channel token_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocateSharedCollectionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AllocateSharedCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateSharedCollectionRequest*>(_write_bytes);
+ _request.token_request = std::move(token_request);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AllocateSharedCollectionRequest));
+ ::fidl::DecodedMessage<AllocateSharedCollectionRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Allocator::InPlace::AllocateSharedCollection(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Allocator::ResultOf::AllocateSharedCollection Allocator::SyncClient::AllocateSharedCollection(::zx::channel token_request) {
+ return ResultOf::AllocateSharedCollection(::zx::unowned_channel(this->channel_), std::move(token_request));
+}
+
+Allocator::ResultOf::AllocateSharedCollection Allocator::Call::AllocateSharedCollection(::zx::unowned_channel _client_end, ::zx::channel token_request) {
+ return ResultOf::AllocateSharedCollection(std::move(_client_end), std::move(token_request));
+}
+
+
+Allocator::UnownedResultOf::AllocateSharedCollection_Impl::AllocateSharedCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel token_request) {
+ if (_request_buffer.capacity() < AllocateSharedCollectionRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, AllocateSharedCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateSharedCollectionRequest*>(_request_buffer.data());
+ _request.token_request = std::move(token_request);
+ _request_buffer.set_actual(sizeof(AllocateSharedCollectionRequest));
+ ::fidl::DecodedMessage<AllocateSharedCollectionRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Allocator::InPlace::AllocateSharedCollection(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Allocator::UnownedResultOf::AllocateSharedCollection Allocator::SyncClient::AllocateSharedCollection(::fidl::BytePart _request_buffer, ::zx::channel token_request) {
+ return UnownedResultOf::AllocateSharedCollection(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(token_request));
+}
+
+Allocator::UnownedResultOf::AllocateSharedCollection Allocator::Call::AllocateSharedCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel token_request) {
+ return UnownedResultOf::AllocateSharedCollection(std::move(_client_end), std::move(_request_buffer), std::move(token_request));
+}
+
+::fidl::internal::StatusAndError Allocator::InPlace::AllocateSharedCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateSharedCollectionRequest> params) {
+ Allocator::SetTransactionHeaderFor::AllocateSharedCollectionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+Allocator::ResultOf::BindSharedCollection_Impl::BindSharedCollection_Impl(::zx::unowned_channel _client_end, ::zx::channel token, ::zx::channel buffer_collection_request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<BindSharedCollectionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, BindSharedCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<BindSharedCollectionRequest*>(_write_bytes);
+ _request.token = std::move(token);
+ _request.buffer_collection_request = std::move(buffer_collection_request);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(BindSharedCollectionRequest));
+ ::fidl::DecodedMessage<BindSharedCollectionRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Allocator::InPlace::BindSharedCollection(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Allocator::ResultOf::BindSharedCollection Allocator::SyncClient::BindSharedCollection(::zx::channel token, ::zx::channel buffer_collection_request) {
+ return ResultOf::BindSharedCollection(::zx::unowned_channel(this->channel_), std::move(token), std::move(buffer_collection_request));
+}
+
+Allocator::ResultOf::BindSharedCollection Allocator::Call::BindSharedCollection(::zx::unowned_channel _client_end, ::zx::channel token, ::zx::channel buffer_collection_request) {
+ return ResultOf::BindSharedCollection(std::move(_client_end), std::move(token), std::move(buffer_collection_request));
+}
+
+
+Allocator::UnownedResultOf::BindSharedCollection_Impl::BindSharedCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel token, ::zx::channel buffer_collection_request) {
+ if (_request_buffer.capacity() < BindSharedCollectionRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, BindSharedCollectionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<BindSharedCollectionRequest*>(_request_buffer.data());
+ _request.token = std::move(token);
+ _request.buffer_collection_request = std::move(buffer_collection_request);
+ _request_buffer.set_actual(sizeof(BindSharedCollectionRequest));
+ ::fidl::DecodedMessage<BindSharedCollectionRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Allocator::InPlace::BindSharedCollection(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Allocator::UnownedResultOf::BindSharedCollection Allocator::SyncClient::BindSharedCollection(::fidl::BytePart _request_buffer, ::zx::channel token, ::zx::channel buffer_collection_request) {
+ return UnownedResultOf::BindSharedCollection(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(token), std::move(buffer_collection_request));
+}
+
+Allocator::UnownedResultOf::BindSharedCollection Allocator::Call::BindSharedCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel token, ::zx::channel buffer_collection_request) {
+ return UnownedResultOf::BindSharedCollection(std::move(_client_end), std::move(_request_buffer), std::move(token), std::move(buffer_collection_request));
+}
+
+::fidl::internal::StatusAndError Allocator::InPlace::BindSharedCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindSharedCollectionRequest> params) {
+ Allocator::SetTransactionHeaderFor::BindSharedCollectionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Allocator::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kAllocator_AllocateNonSharedCollection_Ordinal:
+ case kAllocator_AllocateNonSharedCollection_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AllocateNonSharedCollectionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AllocateNonSharedCollection(std::move(message->collection),
+ Interface::AllocateNonSharedCollectionCompleter::Sync(txn));
+ return true;
+ }
+ case kAllocator_AllocateSharedCollection_Ordinal:
+ case kAllocator_AllocateSharedCollection_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AllocateSharedCollectionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AllocateSharedCollection(std::move(message->token_request),
+ Interface::AllocateSharedCollectionCompleter::Sync(txn));
+ return true;
+ }
+ case kAllocator_BindSharedCollection_Ordinal:
+ case kAllocator_BindSharedCollection_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<BindSharedCollectionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->BindSharedCollection(std::move(message->token), std::move(message->buffer_collection_request),
+ Interface::BindSharedCollectionCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Allocator::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void Allocator::SetTransactionHeaderFor::AllocateNonSharedCollectionRequest(const ::fidl::DecodedMessage<Allocator::AllocateNonSharedCollectionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAllocator_AllocateNonSharedCollection_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Allocator::SetTransactionHeaderFor::AllocateSharedCollectionRequest(const ::fidl::DecodedMessage<Allocator::AllocateSharedCollectionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAllocator_AllocateSharedCollection_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Allocator::SetTransactionHeaderFor::BindSharedCollectionRequest(const ::fidl::DecodedMessage<Allocator::BindSharedCollectionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kAllocator_BindSharedCollection_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(SecureMem_SetPhysicalSecureHeaps_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(SecureMem_SetPhysicalSecureHeaps_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(SecureMem_SetPhysicalSecureHeaps_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+void ::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Result::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(SecureMem_GetPhysicalSecureHeaps_Result) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(SecureMem_GetPhysicalSecureHeaps_Result, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(SecureMem_GetPhysicalSecureHeaps_Result, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kSecureMem_GetPhysicalSecureHeaps_Ordinal = 0x60f3c45a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSecureMem_GetPhysicalSecureHeaps_GenOrdinal = 0x782319d6ce7fa05lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMemGetPhysicalSecureHeapsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMemGetPhysicalSecureHeapsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSecureMem_SetPhysicalSecureHeaps_Ordinal = 0x14b0c0000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSecureMem_SetPhysicalSecureHeaps_GenOrdinal = 0x75a89c33ee8a5d7elu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMemSetPhysicalSecureHeapsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMemSetPhysicalSecureHeapsResponseTable;
+
+} // namespace
+template <>
+SecureMem::ResultOf::GetPhysicalSecureHeaps_Impl<SecureMem::GetPhysicalSecureHeapsResponse>::GetPhysicalSecureHeaps_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPhysicalSecureHeapsRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetPhysicalSecureHeapsRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetPhysicalSecureHeapsRequest));
+ ::fidl::DecodedMessage<GetPhysicalSecureHeapsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SecureMem::InPlace::GetPhysicalSecureHeaps(std::move(_client_end), Super::response_buffer()));
+}
+
+SecureMem::ResultOf::GetPhysicalSecureHeaps SecureMem::SyncClient::GetPhysicalSecureHeaps() {
+ return ResultOf::GetPhysicalSecureHeaps(::zx::unowned_channel(this->channel_));
+}
+
+SecureMem::ResultOf::GetPhysicalSecureHeaps SecureMem::Call::GetPhysicalSecureHeaps(::zx::unowned_channel _client_end) {
+ return ResultOf::GetPhysicalSecureHeaps(std::move(_client_end));
+}
+
+template <>
+SecureMem::UnownedResultOf::GetPhysicalSecureHeaps_Impl<SecureMem::GetPhysicalSecureHeapsResponse>::GetPhysicalSecureHeaps_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetPhysicalSecureHeapsRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetPhysicalSecureHeapsRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetPhysicalSecureHeapsRequest));
+ ::fidl::DecodedMessage<GetPhysicalSecureHeapsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SecureMem::InPlace::GetPhysicalSecureHeaps(std::move(_client_end), std::move(_response_buffer)));
+}
+
+SecureMem::UnownedResultOf::GetPhysicalSecureHeaps SecureMem::SyncClient::GetPhysicalSecureHeaps(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPhysicalSecureHeaps(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+SecureMem::UnownedResultOf::GetPhysicalSecureHeaps SecureMem::Call::GetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetPhysicalSecureHeaps(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SecureMem::GetPhysicalSecureHeapsResponse> SecureMem::InPlace::GetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetPhysicalSecureHeapsRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetPhysicalSecureHeapsRequest> params(std::move(_request_buffer));
+ SecureMem::SetTransactionHeaderFor::GetPhysicalSecureHeapsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SecureMem::GetPhysicalSecureHeapsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetPhysicalSecureHeapsRequest, GetPhysicalSecureHeapsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SecureMem::GetPhysicalSecureHeapsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+SecureMem::ResultOf::SetPhysicalSecureHeaps_Impl<SecureMem::SetPhysicalSecureHeapsResponse>::SetPhysicalSecureHeaps_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetPhysicalSecureHeapsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetPhysicalSecureHeapsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetPhysicalSecureHeapsRequest*>(_write_bytes);
+ _request.heaps = std::move(heaps);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetPhysicalSecureHeapsRequest));
+ ::fidl::DecodedMessage<SetPhysicalSecureHeapsRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ SecureMem::InPlace::SetPhysicalSecureHeaps(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+SecureMem::ResultOf::SetPhysicalSecureHeaps SecureMem::SyncClient::SetPhysicalSecureHeaps(::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps) {
+ return ResultOf::SetPhysicalSecureHeaps(::zx::unowned_channel(this->channel_), std::move(heaps));
+}
+
+SecureMem::ResultOf::SetPhysicalSecureHeaps SecureMem::Call::SetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps) {
+ return ResultOf::SetPhysicalSecureHeaps(std::move(_client_end), std::move(heaps));
+}
+
+template <>
+SecureMem::UnownedResultOf::SetPhysicalSecureHeaps_Impl<SecureMem::SetPhysicalSecureHeapsResponse>::SetPhysicalSecureHeaps_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < SetPhysicalSecureHeapsRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<SetPhysicalSecureHeapsResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetPhysicalSecureHeapsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetPhysicalSecureHeapsRequest*>(_request_buffer.data());
+ _request.heaps = std::move(heaps);
+ _request_buffer.set_actual(sizeof(SetPhysicalSecureHeapsRequest));
+ ::fidl::DecodedMessage<SetPhysicalSecureHeapsRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ SecureMem::InPlace::SetPhysicalSecureHeaps(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+SecureMem::UnownedResultOf::SetPhysicalSecureHeaps SecureMem::SyncClient::SetPhysicalSecureHeaps(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetPhysicalSecureHeaps(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(heaps), std::move(_response_buffer));
+}
+
+SecureMem::UnownedResultOf::SetPhysicalSecureHeaps SecureMem::Call::SetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::SetPhysicalSecureHeaps(std::move(_client_end), std::move(_request_buffer), std::move(heaps), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<SecureMem::SetPhysicalSecureHeapsResponse> SecureMem::InPlace::SetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPhysicalSecureHeapsRequest> params, ::fidl::BytePart response_buffer) {
+ SecureMem::SetTransactionHeaderFor::SetPhysicalSecureHeapsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SecureMem::SetPhysicalSecureHeapsResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SetPhysicalSecureHeapsRequest, SetPhysicalSecureHeapsResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<SecureMem::SetPhysicalSecureHeapsResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool SecureMem::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kSecureMem_GetPhysicalSecureHeaps_Ordinal:
+ case kSecureMem_GetPhysicalSecureHeaps_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetPhysicalSecureHeapsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetPhysicalSecureHeaps(
+ Interface::GetPhysicalSecureHeapsCompleter::Sync(txn));
+ return true;
+ }
+ case kSecureMem_SetPhysicalSecureHeaps_Ordinal:
+ case kSecureMem_SetPhysicalSecureHeaps_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetPhysicalSecureHeapsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetPhysicalSecureHeaps(std::move(message->heaps),
+ Interface::SetPhysicalSecureHeapsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool SecureMem::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void SecureMem::Interface::GetPhysicalSecureHeapsCompleterBase::Reply(::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetPhysicalSecureHeapsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetPhysicalSecureHeapsResponse _response = {};
+ SecureMem::SetTransactionHeaderFor::GetPhysicalSecureHeapsResponse(
+ ::fidl::DecodedMessage<GetPhysicalSecureHeapsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPhysicalSecureHeapsResponse::PrimarySize,
+ GetPhysicalSecureHeapsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void SecureMem::Interface::GetPhysicalSecureHeapsCompleterBase::ReplySuccess(::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps) {
+ SecureMem_GetPhysicalSecureHeaps_Response response;
+ response.heaps = std::move(heaps);
+
+ Reply(SecureMem_GetPhysicalSecureHeaps_Result::WithResponse(&response));
+}
+void SecureMem::Interface::GetPhysicalSecureHeapsCompleterBase::ReplyError(int32_t error) {
+ Reply(SecureMem_GetPhysicalSecureHeaps_Result::WithErr(&error));
+}
+
+void SecureMem::Interface::GetPhysicalSecureHeapsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Result result) {
+ if (_buffer.capacity() < GetPhysicalSecureHeapsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetPhysicalSecureHeapsResponse _response = {};
+ SecureMem::SetTransactionHeaderFor::GetPhysicalSecureHeapsResponse(
+ ::fidl::DecodedMessage<GetPhysicalSecureHeapsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetPhysicalSecureHeapsResponse::PrimarySize,
+ GetPhysicalSecureHeapsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void SecureMem::Interface::GetPhysicalSecureHeapsCompleterBase::ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps) {
+ SecureMem_GetPhysicalSecureHeaps_Response response;
+ response.heaps = std::move(heaps);
+
+ Reply(std::move(_buffer), SecureMem_GetPhysicalSecureHeaps_Result::WithResponse(&response));
+}
+
+void SecureMem::Interface::GetPhysicalSecureHeapsCompleterBase::Reply(::fidl::DecodedMessage<GetPhysicalSecureHeapsResponse> params) {
+ SecureMem::SetTransactionHeaderFor::GetPhysicalSecureHeapsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void SecureMem::Interface::SetPhysicalSecureHeapsCompleterBase::Reply(::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Result result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetPhysicalSecureHeapsResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ SetPhysicalSecureHeapsResponse _response = {};
+ SecureMem::SetTransactionHeaderFor::SetPhysicalSecureHeapsResponse(
+ ::fidl::DecodedMessage<SetPhysicalSecureHeapsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetPhysicalSecureHeapsResponse::PrimarySize,
+ SetPhysicalSecureHeapsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void SecureMem::Interface::SetPhysicalSecureHeapsCompleterBase::ReplySuccess() {
+ SecureMem_SetPhysicalSecureHeaps_Response response;
+
+ Reply(SecureMem_SetPhysicalSecureHeaps_Result::WithResponse(&response));
+}
+void SecureMem::Interface::SetPhysicalSecureHeapsCompleterBase::ReplyError(int32_t error) {
+ Reply(SecureMem_SetPhysicalSecureHeaps_Result::WithErr(&error));
+}
+
+void SecureMem::Interface::SetPhysicalSecureHeapsCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Result result) {
+ if (_buffer.capacity() < SetPhysicalSecureHeapsResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ SetPhysicalSecureHeapsResponse _response = {};
+ SecureMem::SetTransactionHeaderFor::SetPhysicalSecureHeapsResponse(
+ ::fidl::DecodedMessage<SetPhysicalSecureHeapsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SetPhysicalSecureHeapsResponse::PrimarySize,
+ SetPhysicalSecureHeapsResponse::PrimarySize)));
+ _response.result = std::move(result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+void SecureMem::Interface::SetPhysicalSecureHeapsCompleterBase::ReplySuccess(::fidl::BytePart _buffer) {
+ SecureMem_SetPhysicalSecureHeaps_Response response;
+
+ Reply(std::move(_buffer), SecureMem_SetPhysicalSecureHeaps_Result::WithResponse(&response));
+}
+
+void SecureMem::Interface::SetPhysicalSecureHeapsCompleterBase::Reply(::fidl::DecodedMessage<SetPhysicalSecureHeapsResponse> params) {
+ SecureMem::SetTransactionHeaderFor::SetPhysicalSecureHeapsResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void SecureMem::SetTransactionHeaderFor::GetPhysicalSecureHeapsRequest(const ::fidl::DecodedMessage<SecureMem::GetPhysicalSecureHeapsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSecureMem_GetPhysicalSecureHeaps_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SecureMem::SetTransactionHeaderFor::GetPhysicalSecureHeapsResponse(const ::fidl::DecodedMessage<SecureMem::GetPhysicalSecureHeapsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSecureMem_GetPhysicalSecureHeaps_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void SecureMem::SetTransactionHeaderFor::SetPhysicalSecureHeapsRequest(const ::fidl::DecodedMessage<SecureMem::SetPhysicalSecureHeapsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSecureMem_SetPhysicalSecureHeaps_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void SecureMem::SetTransactionHeaderFor::SetPhysicalSecureHeapsResponse(const ::fidl::DecodedMessage<SecureMem::SetPhysicalSecureHeapsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSecureMem_SetPhysicalSecureHeaps_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionEvents_OnDuplicatedTokensKnownByServer_Ordinal = 0x1f54cf3600000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionEvents_OnDuplicatedTokensKnownByServer_GenOrdinal = 0x676c26fb29b9556alu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnDuplicatedTokensKnownByServerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnDuplicatedTokensKnownByServerResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionEvents_OnBuffersAllocated_Ordinal = 0x6830ec5f00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionEvents_OnBuffersAllocated_GenOrdinal = 0x4b74d7c0dc6d8903lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnBuffersAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnBuffersAllocatedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionEvents_OnAllocateSingleBufferDone_Ordinal = 0x6cb2333900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollectionEvents_OnAllocateSingleBufferDone_GenOrdinal = 0x3acc52158e4ff771lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnAllocateSingleBufferDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnAllocateSingleBufferDoneResponseTable;
+
+} // namespace
+
+BufferCollectionEvents::ResultOf::OnDuplicatedTokensKnownByServer_Impl::OnDuplicatedTokensKnownByServer_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnDuplicatedTokensKnownByServerRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, OnDuplicatedTokensKnownByServerRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnDuplicatedTokensKnownByServerRequest));
+ ::fidl::DecodedMessage<OnDuplicatedTokensKnownByServerRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollectionEvents::InPlace::OnDuplicatedTokensKnownByServer(std::move(_client_end)));
+}
+
+BufferCollectionEvents::ResultOf::OnDuplicatedTokensKnownByServer BufferCollectionEvents::SyncClient::OnDuplicatedTokensKnownByServer() {
+ return ResultOf::OnDuplicatedTokensKnownByServer(::zx::unowned_channel(this->channel_));
+}
+
+BufferCollectionEvents::ResultOf::OnDuplicatedTokensKnownByServer BufferCollectionEvents::Call::OnDuplicatedTokensKnownByServer(::zx::unowned_channel _client_end) {
+ return ResultOf::OnDuplicatedTokensKnownByServer(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError BufferCollectionEvents::InPlace::OnDuplicatedTokensKnownByServer(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(OnDuplicatedTokensKnownByServerRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<OnDuplicatedTokensKnownByServerRequest> params(std::move(_request_buffer));
+ BufferCollectionEvents::SetTransactionHeaderFor::OnDuplicatedTokensKnownByServerRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+BufferCollectionEvents::ResultOf::OnBuffersAllocated_Impl::OnBuffersAllocated_Impl(::zx::unowned_channel _client_end, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnBuffersAllocatedRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, OnBuffersAllocatedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OnBuffersAllocatedRequest*>(_write_bytes);
+ _request.status = std::move(status);
+ _request.buffer_collection_info = std::move(buffer_collection_info);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnBuffersAllocatedRequest));
+ ::fidl::DecodedMessage<OnBuffersAllocatedRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollectionEvents::InPlace::OnBuffersAllocated(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollectionEvents::ResultOf::OnBuffersAllocated BufferCollectionEvents::SyncClient::OnBuffersAllocated(int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info) {
+ return ResultOf::OnBuffersAllocated(::zx::unowned_channel(this->channel_), std::move(status), std::move(buffer_collection_info));
+}
+
+BufferCollectionEvents::ResultOf::OnBuffersAllocated BufferCollectionEvents::Call::OnBuffersAllocated(::zx::unowned_channel _client_end, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info) {
+ return ResultOf::OnBuffersAllocated(std::move(_client_end), std::move(status), std::move(buffer_collection_info));
+}
+
+
+BufferCollectionEvents::UnownedResultOf::OnBuffersAllocated_Impl::OnBuffersAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info) {
+ if (_request_buffer.capacity() < OnBuffersAllocatedRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, OnBuffersAllocatedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OnBuffersAllocatedRequest*>(_request_buffer.data());
+ _request.status = std::move(status);
+ _request.buffer_collection_info = std::move(buffer_collection_info);
+ _request_buffer.set_actual(sizeof(OnBuffersAllocatedRequest));
+ ::fidl::DecodedMessage<OnBuffersAllocatedRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BufferCollectionEvents::InPlace::OnBuffersAllocated(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollectionEvents::UnownedResultOf::OnBuffersAllocated BufferCollectionEvents::SyncClient::OnBuffersAllocated(::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info) {
+ return UnownedResultOf::OnBuffersAllocated(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(status), std::move(buffer_collection_info));
+}
+
+BufferCollectionEvents::UnownedResultOf::OnBuffersAllocated BufferCollectionEvents::Call::OnBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info) {
+ return UnownedResultOf::OnBuffersAllocated(std::move(_client_end), std::move(_request_buffer), std::move(status), std::move(buffer_collection_info));
+}
+
+::fidl::internal::StatusAndError BufferCollectionEvents::InPlace::OnBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnBuffersAllocatedRequest> params) {
+ BufferCollectionEvents::SetTransactionHeaderFor::OnBuffersAllocatedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+BufferCollectionEvents::ResultOf::OnAllocateSingleBufferDone_Impl::OnAllocateSingleBufferDone_Impl(::zx::unowned_channel _client_end, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnAllocateSingleBufferDoneRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, OnAllocateSingleBufferDoneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OnAllocateSingleBufferDoneRequest*>(_write_bytes);
+ _request.status = std::move(status);
+ _request.buffer_info = std::move(buffer_info);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(OnAllocateSingleBufferDoneRequest));
+ ::fidl::DecodedMessage<OnAllocateSingleBufferDoneRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollectionEvents::InPlace::OnAllocateSingleBufferDone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollectionEvents::ResultOf::OnAllocateSingleBufferDone BufferCollectionEvents::SyncClient::OnAllocateSingleBufferDone(int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info) {
+ return ResultOf::OnAllocateSingleBufferDone(::zx::unowned_channel(this->channel_), std::move(status), std::move(buffer_info));
+}
+
+BufferCollectionEvents::ResultOf::OnAllocateSingleBufferDone BufferCollectionEvents::Call::OnAllocateSingleBufferDone(::zx::unowned_channel _client_end, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info) {
+ return ResultOf::OnAllocateSingleBufferDone(std::move(_client_end), std::move(status), std::move(buffer_info));
+}
+
+
+BufferCollectionEvents::UnownedResultOf::OnAllocateSingleBufferDone_Impl::OnAllocateSingleBufferDone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info) {
+ if (_request_buffer.capacity() < OnAllocateSingleBufferDoneRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, OnAllocateSingleBufferDoneRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<OnAllocateSingleBufferDoneRequest*>(_request_buffer.data());
+ _request.status = std::move(status);
+ _request.buffer_info = std::move(buffer_info);
+ _request_buffer.set_actual(sizeof(OnAllocateSingleBufferDoneRequest));
+ ::fidl::DecodedMessage<OnAllocateSingleBufferDoneRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BufferCollectionEvents::InPlace::OnAllocateSingleBufferDone(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollectionEvents::UnownedResultOf::OnAllocateSingleBufferDone BufferCollectionEvents::SyncClient::OnAllocateSingleBufferDone(::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info) {
+ return UnownedResultOf::OnAllocateSingleBufferDone(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(status), std::move(buffer_info));
+}
+
+BufferCollectionEvents::UnownedResultOf::OnAllocateSingleBufferDone BufferCollectionEvents::Call::OnAllocateSingleBufferDone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info) {
+ return UnownedResultOf::OnAllocateSingleBufferDone(std::move(_client_end), std::move(_request_buffer), std::move(status), std::move(buffer_info));
+}
+
+::fidl::internal::StatusAndError BufferCollectionEvents::InPlace::OnAllocateSingleBufferDone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnAllocateSingleBufferDoneRequest> params) {
+ BufferCollectionEvents::SetTransactionHeaderFor::OnAllocateSingleBufferDoneRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool BufferCollectionEvents::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBufferCollectionEvents_OnDuplicatedTokensKnownByServer_Ordinal:
+ case kBufferCollectionEvents_OnDuplicatedTokensKnownByServer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnDuplicatedTokensKnownByServerRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->OnDuplicatedTokensKnownByServer(
+ Interface::OnDuplicatedTokensKnownByServerCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollectionEvents_OnBuffersAllocated_Ordinal:
+ case kBufferCollectionEvents_OnBuffersAllocated_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnBuffersAllocatedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OnBuffersAllocated(std::move(message->status), std::move(message->buffer_collection_info),
+ Interface::OnBuffersAllocatedCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollectionEvents_OnAllocateSingleBufferDone_Ordinal:
+ case kBufferCollectionEvents_OnAllocateSingleBufferDone_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnAllocateSingleBufferDoneRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OnAllocateSingleBufferDone(std::move(message->status), std::move(message->buffer_info),
+ Interface::OnAllocateSingleBufferDoneCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool BufferCollectionEvents::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void BufferCollectionEvents::SetTransactionHeaderFor::OnDuplicatedTokensKnownByServerRequest(const ::fidl::DecodedMessage<BufferCollectionEvents::OnDuplicatedTokensKnownByServerRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollectionEvents_OnDuplicatedTokensKnownByServer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollectionEvents::SetTransactionHeaderFor::OnBuffersAllocatedRequest(const ::fidl::DecodedMessage<BufferCollectionEvents::OnBuffersAllocatedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollectionEvents_OnBuffersAllocated_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollectionEvents::SetTransactionHeaderFor::OnAllocateSingleBufferDoneRequest(const ::fidl::DecodedMessage<BufferCollectionEvents::OnAllocateSingleBufferDoneRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollectionEvents_OnAllocateSingleBufferDone_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_SetEventSink_Ordinal = 0x154ba43000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_SetEventSink_GenOrdinal = 0x7e48a6aac582e3c6lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSetEventSinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSetEventSinkResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_Sync_Ordinal = 0x15ba322100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_Sync_GenOrdinal = 0x941fdbb6ec7f85elu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSyncResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_SetConstraints_Ordinal = 0x541b637e00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_SetConstraints_GenOrdinal = 0x4d9c3406c213227blu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSetConstraintsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSetConstraintsResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_WaitForBuffersAllocated_Ordinal = 0x1b36cfa800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_WaitForBuffersAllocated_GenOrdinal = 0x714667ea2a29a3a2lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionWaitForBuffersAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionWaitForBuffersAllocatedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_CheckBuffersAllocated_Ordinal = 0x95520ce00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_CheckBuffersAllocated_GenOrdinal = 0x245bb81f79189e9lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCheckBuffersAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCheckBuffersAllocatedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_CloseSingleBuffer_Ordinal = 0x1802fa4800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_CloseSingleBuffer_GenOrdinal = 0x3becedeb5959121alu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCloseSingleBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCloseSingleBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_AllocateSingleBuffer_Ordinal = 0x1ba0786400000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_AllocateSingleBuffer_GenOrdinal = 0x19cca74dfad8f2bflu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionAllocateSingleBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionAllocateSingleBufferResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_WaitForSingleBufferAllocated_Ordinal = 0x36e6672300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_WaitForSingleBufferAllocated_GenOrdinal = 0x25ee1433c5fd1dclu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionWaitForSingleBufferAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionWaitForSingleBufferAllocatedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_CheckSingleBufferAllocated_Ordinal = 0x1301391c00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_CheckSingleBufferAllocated_GenOrdinal = 0x5905702f25c60301lu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCheckSingleBufferAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCheckSingleBufferAllocatedResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_Close_Ordinal = 0x607c571800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kBufferCollection_Close_GenOrdinal = 0x48ac4179438f99felu;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCloseResponseTable;
+
+} // namespace
+
+BufferCollection::ResultOf::SetEventSink_Impl::SetEventSink_Impl(::zx::unowned_channel _client_end, ::zx::channel events) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetEventSinkRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetEventSinkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetEventSinkRequest*>(_write_bytes);
+ _request.events = std::move(events);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetEventSinkRequest));
+ ::fidl::DecodedMessage<SetEventSinkRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollection::InPlace::SetEventSink(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::ResultOf::SetEventSink BufferCollection::SyncClient::SetEventSink(::zx::channel events) {
+ return ResultOf::SetEventSink(::zx::unowned_channel(this->channel_), std::move(events));
+}
+
+BufferCollection::ResultOf::SetEventSink BufferCollection::Call::SetEventSink(::zx::unowned_channel _client_end, ::zx::channel events) {
+ return ResultOf::SetEventSink(std::move(_client_end), std::move(events));
+}
+
+
+BufferCollection::UnownedResultOf::SetEventSink_Impl::SetEventSink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel events) {
+ if (_request_buffer.capacity() < SetEventSinkRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetEventSinkRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetEventSinkRequest*>(_request_buffer.data());
+ _request.events = std::move(events);
+ _request_buffer.set_actual(sizeof(SetEventSinkRequest));
+ ::fidl::DecodedMessage<SetEventSinkRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BufferCollection::InPlace::SetEventSink(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::UnownedResultOf::SetEventSink BufferCollection::SyncClient::SetEventSink(::fidl::BytePart _request_buffer, ::zx::channel events) {
+ return UnownedResultOf::SetEventSink(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(events));
+}
+
+BufferCollection::UnownedResultOf::SetEventSink BufferCollection::Call::SetEventSink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel events) {
+ return UnownedResultOf::SetEventSink(std::move(_client_end), std::move(_request_buffer), std::move(events));
+}
+
+::fidl::internal::StatusAndError BufferCollection::InPlace::SetEventSink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetEventSinkRequest> params) {
+ BufferCollection::SetTransactionHeaderFor::SetEventSinkRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+BufferCollection::ResultOf::Sync_Impl<BufferCollection::SyncResponse>::Sync_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SyncRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncRequest));
+ ::fidl::DecodedMessage<SyncRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BufferCollection::InPlace::Sync(std::move(_client_end), Super::response_buffer()));
+}
+
+BufferCollection::ResultOf::Sync BufferCollection::SyncClient::Sync() {
+ return ResultOf::Sync(::zx::unowned_channel(this->channel_));
+}
+
+BufferCollection::ResultOf::Sync BufferCollection::Call::Sync(::zx::unowned_channel _client_end) {
+ return ResultOf::Sync(std::move(_client_end));
+}
+
+::fidl::DecodeResult<BufferCollection::SyncResponse> BufferCollection::InPlace::Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(SyncRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<SyncRequest> params(std::move(_request_buffer));
+ BufferCollection::SetTransactionHeaderFor::SyncRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollection::SyncResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<SyncRequest, SyncResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollection::SyncResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+BufferCollection::ResultOf::SetConstraints_Impl::SetConstraints_Impl(::zx::unowned_channel _client_end, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SetConstraintsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, SetConstraintsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConstraintsRequest*>(_write_bytes);
+ _request.has_constraints = std::move(has_constraints);
+ _request.constraints = std::move(constraints);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(SetConstraintsRequest));
+ ::fidl::DecodedMessage<SetConstraintsRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollection::InPlace::SetConstraints(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::ResultOf::SetConstraints BufferCollection::SyncClient::SetConstraints(bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints) {
+ return ResultOf::SetConstraints(::zx::unowned_channel(this->channel_), std::move(has_constraints), std::move(constraints));
+}
+
+BufferCollection::ResultOf::SetConstraints BufferCollection::Call::SetConstraints(::zx::unowned_channel _client_end, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints) {
+ return ResultOf::SetConstraints(std::move(_client_end), std::move(has_constraints), std::move(constraints));
+}
+
+
+BufferCollection::UnownedResultOf::SetConstraints_Impl::SetConstraints_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints) {
+ if (_request_buffer.capacity() < SetConstraintsRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, SetConstraintsRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<SetConstraintsRequest*>(_request_buffer.data());
+ _request.has_constraints = std::move(has_constraints);
+ _request.constraints = std::move(constraints);
+ _request_buffer.set_actual(sizeof(SetConstraintsRequest));
+ ::fidl::DecodedMessage<SetConstraintsRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BufferCollection::InPlace::SetConstraints(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::UnownedResultOf::SetConstraints BufferCollection::SyncClient::SetConstraints(::fidl::BytePart _request_buffer, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints) {
+ return UnownedResultOf::SetConstraints(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(has_constraints), std::move(constraints));
+}
+
+BufferCollection::UnownedResultOf::SetConstraints BufferCollection::Call::SetConstraints(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints) {
+ return UnownedResultOf::SetConstraints(std::move(_client_end), std::move(_request_buffer), std::move(has_constraints), std::move(constraints));
+}
+
+::fidl::internal::StatusAndError BufferCollection::InPlace::SetConstraints(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConstraintsRequest> params) {
+ BufferCollection::SetTransactionHeaderFor::SetConstraintsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+BufferCollection::ResultOf::WaitForBuffersAllocated_Impl<BufferCollection::WaitForBuffersAllocatedResponse>::WaitForBuffersAllocated_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WaitForBuffersAllocatedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WaitForBuffersAllocatedRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WaitForBuffersAllocatedRequest));
+ ::fidl::DecodedMessage<WaitForBuffersAllocatedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BufferCollection::InPlace::WaitForBuffersAllocated(std::move(_client_end), Super::response_buffer()));
+}
+
+BufferCollection::ResultOf::WaitForBuffersAllocated BufferCollection::SyncClient::WaitForBuffersAllocated() {
+ return ResultOf::WaitForBuffersAllocated(::zx::unowned_channel(this->channel_));
+}
+
+BufferCollection::ResultOf::WaitForBuffersAllocated BufferCollection::Call::WaitForBuffersAllocated(::zx::unowned_channel _client_end) {
+ return ResultOf::WaitForBuffersAllocated(std::move(_client_end));
+}
+
+template <>
+BufferCollection::UnownedResultOf::WaitForBuffersAllocated_Impl<BufferCollection::WaitForBuffersAllocatedResponse>::WaitForBuffersAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(WaitForBuffersAllocatedRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, WaitForBuffersAllocatedRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(WaitForBuffersAllocatedRequest));
+ ::fidl::DecodedMessage<WaitForBuffersAllocatedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BufferCollection::InPlace::WaitForBuffersAllocated(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BufferCollection::UnownedResultOf::WaitForBuffersAllocated BufferCollection::SyncClient::WaitForBuffersAllocated(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WaitForBuffersAllocated(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BufferCollection::UnownedResultOf::WaitForBuffersAllocated BufferCollection::Call::WaitForBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WaitForBuffersAllocated(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BufferCollection::WaitForBuffersAllocatedResponse> BufferCollection::InPlace::WaitForBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(WaitForBuffersAllocatedRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<WaitForBuffersAllocatedRequest> params(std::move(_request_buffer));
+ BufferCollection::SetTransactionHeaderFor::WaitForBuffersAllocatedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollection::WaitForBuffersAllocatedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WaitForBuffersAllocatedRequest, WaitForBuffersAllocatedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollection::WaitForBuffersAllocatedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+BufferCollection::ResultOf::CheckBuffersAllocated_Impl<BufferCollection::CheckBuffersAllocatedResponse>::CheckBuffersAllocated_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CheckBuffersAllocatedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CheckBuffersAllocatedRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CheckBuffersAllocatedRequest));
+ ::fidl::DecodedMessage<CheckBuffersAllocatedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BufferCollection::InPlace::CheckBuffersAllocated(std::move(_client_end), Super::response_buffer()));
+}
+
+BufferCollection::ResultOf::CheckBuffersAllocated BufferCollection::SyncClient::CheckBuffersAllocated() {
+ return ResultOf::CheckBuffersAllocated(::zx::unowned_channel(this->channel_));
+}
+
+BufferCollection::ResultOf::CheckBuffersAllocated BufferCollection::Call::CheckBuffersAllocated(::zx::unowned_channel _client_end) {
+ return ResultOf::CheckBuffersAllocated(std::move(_client_end));
+}
+
+template <>
+BufferCollection::UnownedResultOf::CheckBuffersAllocated_Impl<BufferCollection::CheckBuffersAllocatedResponse>::CheckBuffersAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CheckBuffersAllocatedRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CheckBuffersAllocatedRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CheckBuffersAllocatedRequest));
+ ::fidl::DecodedMessage<CheckBuffersAllocatedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BufferCollection::InPlace::CheckBuffersAllocated(std::move(_client_end), std::move(_response_buffer)));
+}
+
+BufferCollection::UnownedResultOf::CheckBuffersAllocated BufferCollection::SyncClient::CheckBuffersAllocated(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CheckBuffersAllocated(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+BufferCollection::UnownedResultOf::CheckBuffersAllocated BufferCollection::Call::CheckBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CheckBuffersAllocated(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BufferCollection::CheckBuffersAllocatedResponse> BufferCollection::InPlace::CheckBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CheckBuffersAllocatedRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CheckBuffersAllocatedRequest> params(std::move(_request_buffer));
+ BufferCollection::SetTransactionHeaderFor::CheckBuffersAllocatedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollection::CheckBuffersAllocatedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CheckBuffersAllocatedRequest, CheckBuffersAllocatedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollection::CheckBuffersAllocatedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+BufferCollection::ResultOf::CloseSingleBuffer_Impl::CloseSingleBuffer_Impl(::zx::unowned_channel _client_end, uint64_t buffer_index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseSingleBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseSingleBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloseSingleBufferRequest*>(_write_bytes);
+ _request.buffer_index = std::move(buffer_index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseSingleBufferRequest));
+ ::fidl::DecodedMessage<CloseSingleBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollection::InPlace::CloseSingleBuffer(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::ResultOf::CloseSingleBuffer BufferCollection::SyncClient::CloseSingleBuffer(uint64_t buffer_index) {
+ return ResultOf::CloseSingleBuffer(::zx::unowned_channel(this->channel_), std::move(buffer_index));
+}
+
+BufferCollection::ResultOf::CloseSingleBuffer BufferCollection::Call::CloseSingleBuffer(::zx::unowned_channel _client_end, uint64_t buffer_index) {
+ return ResultOf::CloseSingleBuffer(std::move(_client_end), std::move(buffer_index));
+}
+
+
+BufferCollection::UnownedResultOf::CloseSingleBuffer_Impl::CloseSingleBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ if (_request_buffer.capacity() < CloseSingleBufferRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloseSingleBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloseSingleBufferRequest*>(_request_buffer.data());
+ _request.buffer_index = std::move(buffer_index);
+ _request_buffer.set_actual(sizeof(CloseSingleBufferRequest));
+ ::fidl::DecodedMessage<CloseSingleBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BufferCollection::InPlace::CloseSingleBuffer(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::UnownedResultOf::CloseSingleBuffer BufferCollection::SyncClient::CloseSingleBuffer(::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ return UnownedResultOf::CloseSingleBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(buffer_index));
+}
+
+BufferCollection::UnownedResultOf::CloseSingleBuffer BufferCollection::Call::CloseSingleBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ return UnownedResultOf::CloseSingleBuffer(std::move(_client_end), std::move(_request_buffer), std::move(buffer_index));
+}
+
+::fidl::internal::StatusAndError BufferCollection::InPlace::CloseSingleBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloseSingleBufferRequest> params) {
+ BufferCollection::SetTransactionHeaderFor::CloseSingleBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+BufferCollection::ResultOf::AllocateSingleBuffer_Impl::AllocateSingleBuffer_Impl(::zx::unowned_channel _client_end, uint64_t buffer_index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<AllocateSingleBufferRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, AllocateSingleBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateSingleBufferRequest*>(_write_bytes);
+ _request.buffer_index = std::move(buffer_index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(AllocateSingleBufferRequest));
+ ::fidl::DecodedMessage<AllocateSingleBufferRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollection::InPlace::AllocateSingleBuffer(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::ResultOf::AllocateSingleBuffer BufferCollection::SyncClient::AllocateSingleBuffer(uint64_t buffer_index) {
+ return ResultOf::AllocateSingleBuffer(::zx::unowned_channel(this->channel_), std::move(buffer_index));
+}
+
+BufferCollection::ResultOf::AllocateSingleBuffer BufferCollection::Call::AllocateSingleBuffer(::zx::unowned_channel _client_end, uint64_t buffer_index) {
+ return ResultOf::AllocateSingleBuffer(std::move(_client_end), std::move(buffer_index));
+}
+
+
+BufferCollection::UnownedResultOf::AllocateSingleBuffer_Impl::AllocateSingleBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ if (_request_buffer.capacity() < AllocateSingleBufferRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, AllocateSingleBufferRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<AllocateSingleBufferRequest*>(_request_buffer.data());
+ _request.buffer_index = std::move(buffer_index);
+ _request_buffer.set_actual(sizeof(AllocateSingleBufferRequest));
+ ::fidl::DecodedMessage<AllocateSingleBufferRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BufferCollection::InPlace::AllocateSingleBuffer(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::UnownedResultOf::AllocateSingleBuffer BufferCollection::SyncClient::AllocateSingleBuffer(::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ return UnownedResultOf::AllocateSingleBuffer(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(buffer_index));
+}
+
+BufferCollection::UnownedResultOf::AllocateSingleBuffer BufferCollection::Call::AllocateSingleBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ return UnownedResultOf::AllocateSingleBuffer(std::move(_client_end), std::move(_request_buffer), std::move(buffer_index));
+}
+
+::fidl::internal::StatusAndError BufferCollection::InPlace::AllocateSingleBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateSingleBufferRequest> params) {
+ BufferCollection::SetTransactionHeaderFor::AllocateSingleBufferRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+BufferCollection::ResultOf::WaitForSingleBufferAllocated_Impl<BufferCollection::WaitForSingleBufferAllocatedResponse>::WaitForSingleBufferAllocated_Impl(::zx::unowned_channel _client_end, uint64_t buffer_index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WaitForSingleBufferAllocatedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, WaitForSingleBufferAllocatedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WaitForSingleBufferAllocatedRequest*>(_write_bytes);
+ _request.buffer_index = std::move(buffer_index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(WaitForSingleBufferAllocatedRequest));
+ ::fidl::DecodedMessage<WaitForSingleBufferAllocatedRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ BufferCollection::InPlace::WaitForSingleBufferAllocated(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+BufferCollection::ResultOf::WaitForSingleBufferAllocated BufferCollection::SyncClient::WaitForSingleBufferAllocated(uint64_t buffer_index) {
+ return ResultOf::WaitForSingleBufferAllocated(::zx::unowned_channel(this->channel_), std::move(buffer_index));
+}
+
+BufferCollection::ResultOf::WaitForSingleBufferAllocated BufferCollection::Call::WaitForSingleBufferAllocated(::zx::unowned_channel _client_end, uint64_t buffer_index) {
+ return ResultOf::WaitForSingleBufferAllocated(std::move(_client_end), std::move(buffer_index));
+}
+
+template <>
+BufferCollection::UnownedResultOf::WaitForSingleBufferAllocated_Impl<BufferCollection::WaitForSingleBufferAllocatedResponse>::WaitForSingleBufferAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < WaitForSingleBufferAllocatedRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<WaitForSingleBufferAllocatedResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, WaitForSingleBufferAllocatedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<WaitForSingleBufferAllocatedRequest*>(_request_buffer.data());
+ _request.buffer_index = std::move(buffer_index);
+ _request_buffer.set_actual(sizeof(WaitForSingleBufferAllocatedRequest));
+ ::fidl::DecodedMessage<WaitForSingleBufferAllocatedRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ BufferCollection::InPlace::WaitForSingleBufferAllocated(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+BufferCollection::UnownedResultOf::WaitForSingleBufferAllocated BufferCollection::SyncClient::WaitForSingleBufferAllocated(::fidl::BytePart _request_buffer, uint64_t buffer_index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WaitForSingleBufferAllocated(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(buffer_index), std::move(_response_buffer));
+}
+
+BufferCollection::UnownedResultOf::WaitForSingleBufferAllocated BufferCollection::Call::WaitForSingleBufferAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::WaitForSingleBufferAllocated(std::move(_client_end), std::move(_request_buffer), std::move(buffer_index), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<BufferCollection::WaitForSingleBufferAllocatedResponse> BufferCollection::InPlace::WaitForSingleBufferAllocated(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WaitForSingleBufferAllocatedRequest> params, ::fidl::BytePart response_buffer) {
+ BufferCollection::SetTransactionHeaderFor::WaitForSingleBufferAllocatedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollection::WaitForSingleBufferAllocatedResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<WaitForSingleBufferAllocatedRequest, WaitForSingleBufferAllocatedResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<BufferCollection::WaitForSingleBufferAllocatedResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+BufferCollection::ResultOf::CheckSingleBufferAllocated_Impl::CheckSingleBufferAllocated_Impl(::zx::unowned_channel _client_end, uint64_t buffer_index) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CheckSingleBufferAllocatedRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CheckSingleBufferAllocatedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CheckSingleBufferAllocatedRequest*>(_write_bytes);
+ _request.buffer_index = std::move(buffer_index);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CheckSingleBufferAllocatedRequest));
+ ::fidl::DecodedMessage<CheckSingleBufferAllocatedRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollection::InPlace::CheckSingleBufferAllocated(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::ResultOf::CheckSingleBufferAllocated BufferCollection::SyncClient::CheckSingleBufferAllocated(uint64_t buffer_index) {
+ return ResultOf::CheckSingleBufferAllocated(::zx::unowned_channel(this->channel_), std::move(buffer_index));
+}
+
+BufferCollection::ResultOf::CheckSingleBufferAllocated BufferCollection::Call::CheckSingleBufferAllocated(::zx::unowned_channel _client_end, uint64_t buffer_index) {
+ return ResultOf::CheckSingleBufferAllocated(std::move(_client_end), std::move(buffer_index));
+}
+
+
+BufferCollection::UnownedResultOf::CheckSingleBufferAllocated_Impl::CheckSingleBufferAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ if (_request_buffer.capacity() < CheckSingleBufferAllocatedRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, CheckSingleBufferAllocatedRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CheckSingleBufferAllocatedRequest*>(_request_buffer.data());
+ _request.buffer_index = std::move(buffer_index);
+ _request_buffer.set_actual(sizeof(CheckSingleBufferAllocatedRequest));
+ ::fidl::DecodedMessage<CheckSingleBufferAllocatedRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ BufferCollection::InPlace::CheckSingleBufferAllocated(std::move(_client_end), std::move(_decoded_request)));
+}
+
+BufferCollection::UnownedResultOf::CheckSingleBufferAllocated BufferCollection::SyncClient::CheckSingleBufferAllocated(::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ return UnownedResultOf::CheckSingleBufferAllocated(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(buffer_index));
+}
+
+BufferCollection::UnownedResultOf::CheckSingleBufferAllocated BufferCollection::Call::CheckSingleBufferAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index) {
+ return UnownedResultOf::CheckSingleBufferAllocated(std::move(_client_end), std::move(_request_buffer), std::move(buffer_index));
+}
+
+::fidl::internal::StatusAndError BufferCollection::InPlace::CheckSingleBufferAllocated(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CheckSingleBufferAllocatedRequest> params) {
+ BufferCollection::SetTransactionHeaderFor::CheckSingleBufferAllocatedRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+BufferCollection::ResultOf::Close_Impl::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ BufferCollection::InPlace::Close(std::move(_client_end)));
+}
+
+BufferCollection::ResultOf::Close BufferCollection::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+BufferCollection::ResultOf::Close BufferCollection::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError BufferCollection::InPlace::Close(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ BufferCollection::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool BufferCollection::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kBufferCollection_SetEventSink_Ordinal:
+ case kBufferCollection_SetEventSink_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetEventSinkRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetEventSink(std::move(message->events),
+ Interface::SetEventSinkCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_Sync_Ordinal:
+ case kBufferCollection_Sync_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SyncRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Sync(
+ Interface::SyncCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_SetConstraints_Ordinal:
+ case kBufferCollection_SetConstraints_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<SetConstraintsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->SetConstraints(std::move(message->has_constraints), std::move(message->constraints),
+ Interface::SetConstraintsCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_WaitForBuffersAllocated_Ordinal:
+ case kBufferCollection_WaitForBuffersAllocated_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WaitForBuffersAllocatedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->WaitForBuffersAllocated(
+ Interface::WaitForBuffersAllocatedCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_CheckBuffersAllocated_Ordinal:
+ case kBufferCollection_CheckBuffersAllocated_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CheckBuffersAllocatedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->CheckBuffersAllocated(
+ Interface::CheckBuffersAllocatedCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_CloseSingleBuffer_Ordinal:
+ case kBufferCollection_CloseSingleBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseSingleBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CloseSingleBuffer(std::move(message->buffer_index),
+ Interface::CloseSingleBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_AllocateSingleBuffer_Ordinal:
+ case kBufferCollection_AllocateSingleBuffer_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<AllocateSingleBufferRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->AllocateSingleBuffer(std::move(message->buffer_index),
+ Interface::AllocateSingleBufferCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_WaitForSingleBufferAllocated_Ordinal:
+ case kBufferCollection_WaitForSingleBufferAllocated_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<WaitForSingleBufferAllocatedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->WaitForSingleBufferAllocated(std::move(message->buffer_index),
+ Interface::WaitForSingleBufferAllocatedCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_CheckSingleBufferAllocated_Ordinal:
+ case kBufferCollection_CheckSingleBufferAllocated_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CheckSingleBufferAllocatedRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CheckSingleBufferAllocated(std::move(message->buffer_index),
+ Interface::CheckSingleBufferAllocatedCompleter::Sync(txn));
+ return true;
+ }
+ case kBufferCollection_Close_Ordinal:
+ case kBufferCollection_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool BufferCollection::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void BufferCollection::Interface::SyncCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<SyncResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<SyncResponse*>(_write_bytes);
+ BufferCollection::SetTransactionHeaderFor::SyncResponse(
+ ::fidl::DecodedMessage<SyncResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ SyncResponse::PrimarySize,
+ SyncResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(SyncResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<SyncResponse>(std::move(_response_bytes)));
+}
+
+
+void BufferCollection::Interface::WaitForBuffersAllocatedCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WaitForBuffersAllocatedResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ auto& _response = *reinterpret_cast<WaitForBuffersAllocatedResponse*>(_write_bytes);
+ BufferCollection::SetTransactionHeaderFor::WaitForBuffersAllocatedResponse(
+ ::fidl::DecodedMessage<WaitForBuffersAllocatedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WaitForBuffersAllocatedResponse::PrimarySize,
+ WaitForBuffersAllocatedResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.buffer_collection_info = std::move(buffer_collection_info);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WaitForBuffersAllocatedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WaitForBuffersAllocatedResponse>(std::move(_response_bytes)));
+}
+
+void BufferCollection::Interface::WaitForBuffersAllocatedCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info) {
+ if (_buffer.capacity() < WaitForBuffersAllocatedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WaitForBuffersAllocatedResponse*>(_buffer.data());
+ BufferCollection::SetTransactionHeaderFor::WaitForBuffersAllocatedResponse(
+ ::fidl::DecodedMessage<WaitForBuffersAllocatedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WaitForBuffersAllocatedResponse::PrimarySize,
+ WaitForBuffersAllocatedResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.buffer_collection_info = std::move(buffer_collection_info);
+ _buffer.set_actual(sizeof(WaitForBuffersAllocatedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WaitForBuffersAllocatedResponse>(std::move(_buffer)));
+}
+
+void BufferCollection::Interface::WaitForBuffersAllocatedCompleterBase::Reply(::fidl::DecodedMessage<WaitForBuffersAllocatedResponse> params) {
+ BufferCollection::SetTransactionHeaderFor::WaitForBuffersAllocatedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BufferCollection::Interface::CheckBuffersAllocatedCompleterBase::Reply(int32_t status) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CheckBuffersAllocatedResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CheckBuffersAllocatedResponse*>(_write_bytes);
+ BufferCollection::SetTransactionHeaderFor::CheckBuffersAllocatedResponse(
+ ::fidl::DecodedMessage<CheckBuffersAllocatedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CheckBuffersAllocatedResponse::PrimarySize,
+ CheckBuffersAllocatedResponse::PrimarySize)));
+ _response.status = std::move(status);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CheckBuffersAllocatedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CheckBuffersAllocatedResponse>(std::move(_response_bytes)));
+}
+
+void BufferCollection::Interface::CheckBuffersAllocatedCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status) {
+ if (_buffer.capacity() < CheckBuffersAllocatedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CheckBuffersAllocatedResponse*>(_buffer.data());
+ BufferCollection::SetTransactionHeaderFor::CheckBuffersAllocatedResponse(
+ ::fidl::DecodedMessage<CheckBuffersAllocatedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CheckBuffersAllocatedResponse::PrimarySize,
+ CheckBuffersAllocatedResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _buffer.set_actual(sizeof(CheckBuffersAllocatedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CheckBuffersAllocatedResponse>(std::move(_buffer)));
+}
+
+void BufferCollection::Interface::CheckBuffersAllocatedCompleterBase::Reply(::fidl::DecodedMessage<CheckBuffersAllocatedResponse> params) {
+ BufferCollection::SetTransactionHeaderFor::CheckBuffersAllocatedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void BufferCollection::Interface::WaitForSingleBufferAllocatedCompleterBase::Reply(int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<WaitForSingleBufferAllocatedResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<WaitForSingleBufferAllocatedResponse*>(_write_bytes);
+ BufferCollection::SetTransactionHeaderFor::WaitForSingleBufferAllocatedResponse(
+ ::fidl::DecodedMessage<WaitForSingleBufferAllocatedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WaitForSingleBufferAllocatedResponse::PrimarySize,
+ WaitForSingleBufferAllocatedResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.buffer_info = std::move(buffer_info);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(WaitForSingleBufferAllocatedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WaitForSingleBufferAllocatedResponse>(std::move(_response_bytes)));
+}
+
+void BufferCollection::Interface::WaitForSingleBufferAllocatedCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info) {
+ if (_buffer.capacity() < WaitForSingleBufferAllocatedResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<WaitForSingleBufferAllocatedResponse*>(_buffer.data());
+ BufferCollection::SetTransactionHeaderFor::WaitForSingleBufferAllocatedResponse(
+ ::fidl::DecodedMessage<WaitForSingleBufferAllocatedResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ WaitForSingleBufferAllocatedResponse::PrimarySize,
+ WaitForSingleBufferAllocatedResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.buffer_info = std::move(buffer_info);
+ _buffer.set_actual(sizeof(WaitForSingleBufferAllocatedResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<WaitForSingleBufferAllocatedResponse>(std::move(_buffer)));
+}
+
+void BufferCollection::Interface::WaitForSingleBufferAllocatedCompleterBase::Reply(::fidl::DecodedMessage<WaitForSingleBufferAllocatedResponse> params) {
+ BufferCollection::SetTransactionHeaderFor::WaitForSingleBufferAllocatedResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void BufferCollection::SetTransactionHeaderFor::SetEventSinkRequest(const ::fidl::DecodedMessage<BufferCollection::SetEventSinkRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_SetEventSink_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::SyncRequest(const ::fidl::DecodedMessage<BufferCollection::SyncRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BufferCollection::SetTransactionHeaderFor::SyncResponse(const ::fidl::DecodedMessage<BufferCollection::SyncResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_Sync_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::SetConstraintsRequest(const ::fidl::DecodedMessage<BufferCollection::SetConstraintsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_SetConstraints_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::WaitForBuffersAllocatedRequest(const ::fidl::DecodedMessage<BufferCollection::WaitForBuffersAllocatedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_WaitForBuffersAllocated_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BufferCollection::SetTransactionHeaderFor::WaitForBuffersAllocatedResponse(const ::fidl::DecodedMessage<BufferCollection::WaitForBuffersAllocatedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_WaitForBuffersAllocated_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::CheckBuffersAllocatedRequest(const ::fidl::DecodedMessage<BufferCollection::CheckBuffersAllocatedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_CheckBuffersAllocated_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BufferCollection::SetTransactionHeaderFor::CheckBuffersAllocatedResponse(const ::fidl::DecodedMessage<BufferCollection::CheckBuffersAllocatedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_CheckBuffersAllocated_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::CloseSingleBufferRequest(const ::fidl::DecodedMessage<BufferCollection::CloseSingleBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_CloseSingleBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::AllocateSingleBufferRequest(const ::fidl::DecodedMessage<BufferCollection::AllocateSingleBufferRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_AllocateSingleBuffer_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::WaitForSingleBufferAllocatedRequest(const ::fidl::DecodedMessage<BufferCollection::WaitForSingleBufferAllocatedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_WaitForSingleBufferAllocated_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void BufferCollection::SetTransactionHeaderFor::WaitForSingleBufferAllocatedResponse(const ::fidl::DecodedMessage<BufferCollection::WaitForSingleBufferAllocatedResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_WaitForSingleBufferAllocated_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::CheckSingleBufferAllocatedRequest(const ::fidl::DecodedMessage<BufferCollection::CheckSingleBufferAllocatedRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_CheckSingleBufferAllocated_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void BufferCollection::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<BufferCollection::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kBufferCollection_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace sysmem
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-sysmem/gen/llcpp/include/fuchsia/sysmem/llcpp/fidl.h b/zircon/system/fidl/fuchsia-sysmem/gen/llcpp/include/fuchsia/sysmem/llcpp/fidl.h
new file mode 100644
index 0000000..80ec0e6
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-sysmem/gen/llcpp/include/fuchsia/sysmem/llcpp/fidl.h
@@ -0,0 +1,5878 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace sysmem {
+
+struct VmoBuffer;
+class BufferCollectionToken;
+class Heap;
+class DriverConnector;
+class Allocator;
+struct SecureMem_SetPhysicalSecureHeaps_Response;
+struct SecureMem_SetPhysicalSecureHeaps_Result;
+enum class PixelFormatType : uint32_t {
+ INVALID = 0u,
+ R8G8B8A8 = 1u,
+ BGRA32 = 101u,
+ I420 = 102u,
+ M420 = 103u,
+ NV12 = 104u,
+ YUY2 = 105u,
+ MJPEG = 106u,
+ YV12 = 107u,
+ BGR24 = 108u,
+ RGB565 = 109u,
+ RGB332 = 110u,
+ RGB2220 = 111u,
+ L8 = 112u,
+};
+
+
+struct ImagePlane;
+enum class HeapType : uint64_t {
+ SYSTEM_RAM = 0u,
+ AMLOGIC_SECURE = 1152921504606912512u,
+ AMLOGIC_SECURE_VDEC = 1152921504606912513u,
+ GOLDFISH_DEVICE_LOCAL = 1152921504606978048u,
+};
+
+
+struct PhysicalSecureHeap;
+struct PhysicalSecureHeaps;
+struct SecureMem_GetPhysicalSecureHeaps_Response;
+struct SecureMem_GetPhysicalSecureHeaps_Result;
+class SecureMem;
+struct BufferMemoryConstraints;
+struct FormatModifier;
+struct PixelFormat;
+enum class ColorSpaceType : uint32_t {
+ INVALID = 0u,
+ SRGB = 1u,
+ REC601_NTSC = 2u,
+ REC601_NTSC_FULL_RANGE = 3u,
+ REC601_PAL = 4u,
+ REC601_PAL_FULL_RANGE = 5u,
+ REC709 = 6u,
+ REC2020 = 7u,
+ REC2100 = 8u,
+};
+
+
+struct ColorSpace;
+struct ImageSpec;
+struct ImageFormat_2;
+struct ImageFormatConstraints;
+struct ImageFormat;
+struct BufferFormat;
+struct BufferCollectionInfo;
+enum class CoherencyDomain : uint32_t {
+ CPU = 0u,
+ RAM = 1u,
+ INACCESSIBLE = 2u,
+};
+
+
+struct BufferMemorySettings;
+struct SingleBufferSettings;
+struct SingleBufferInfo;
+struct BufferCollectionInfo_2;
+class BufferCollectionEvents;
+struct BufferUsage;
+struct BufferCollectionConstraints;
+class BufferCollection;
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMem_SetPhysicalSecureHeaps_ResultTable;
+
+struct SecureMem_SetPhysicalSecureHeaps_Result {
+ SecureMem_SetPhysicalSecureHeaps_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static SecureMem_SetPhysicalSecureHeaps_Result WithResponse(::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response* val) {
+ SecureMem_SetPhysicalSecureHeaps_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static SecureMem_SetPhysicalSecureHeaps_Result WithErr(int32_t* val) {
+ SecureMem_SetPhysicalSecureHeaps_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SecureMem_SetPhysicalSecureHeaps_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMem_GetPhysicalSecureHeaps_ResultTable;
+
+struct SecureMem_GetPhysicalSecureHeaps_Result {
+ SecureMem_GetPhysicalSecureHeaps_Result() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_response() const { return ordinal() == Ordinal::kResponse; }
+
+ static SecureMem_GetPhysicalSecureHeaps_Result WithResponse(::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response* val) {
+ SecureMem_GetPhysicalSecureHeaps_Result result;
+ result.set_response(val);
+ return result;
+ }
+
+ void set_response(::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response* elem) {
+ ordinal_ = Ordinal::kResponse;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response& mutable_response() {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response& response() const {
+ ZX_ASSERT(ordinal() == Ordinal::kResponse);
+ return *static_cast<::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response*>(envelope_.data);
+ }
+
+ bool is_err() const { return ordinal() == Ordinal::kErr; }
+
+ static SecureMem_GetPhysicalSecureHeaps_Result WithErr(int32_t* val) {
+ SecureMem_GetPhysicalSecureHeaps_Result result;
+ result.set_err(val);
+ return result;
+ }
+
+ void set_err(int32_t* elem) {
+ ordinal_ = Ordinal::kErr;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ int32_t& mutable_err() {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ const int32_t& err() const {
+ ZX_ASSERT(ordinal() == Ordinal::kErr);
+ return *static_cast<int32_t*>(envelope_.data);
+ }
+ Tag which() const {
+ ZX_ASSERT(!has_invalid_tag());
+ return static_cast<Tag>(ordinal());
+ }
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SecureMem_GetPhysicalSecureHeaps_ResultTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 776;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kResponse = 1, // 0x1
+ kErr = 2, // 0x2
+ };
+
+ Ordinal ordinal() const {
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+constexpr uint32_t vulkanUsageTransientAttachment = 64u;
+
+constexpr uint32_t vulkanUsageTransferSrc = 1u;
+
+constexpr uint32_t vulkanUsageTransferDst = 2u;
+
+constexpr uint32_t vulkanUsageStorage = 8u;
+
+constexpr uint32_t vulkanUsageStencilAttachment = 32u;
+
+constexpr uint32_t vulkanUsageSampled = 4u;
+
+constexpr uint32_t vulkanUsageInputAttachment = 128u;
+
+constexpr uint32_t vulkanUsageColorAttachment = 16u;
+
+constexpr uint32_t videoUsageHwProtected = 4u;
+
+constexpr uint32_t videoUsageHwEncoder = 2u;
+
+constexpr uint32_t videoUsageHwDecoderInternal = 32u;
+
+constexpr uint32_t videoUsageHwDecoder = 1u;
+
+constexpr uint32_t videoUsageDecryptorOutput = 16u;
+
+constexpr uint32_t videoUsageCapture = 8u;
+
+constexpr uint32_t noneUsage = 1u;
+
+constexpr uint32_t displayUsageLayer = 1u;
+
+constexpr uint32_t displayUsageCursor = 2u;
+
+constexpr uint32_t cpuUsageWriteOften = 8u;
+
+constexpr uint32_t cpuUsageWrite = 4u;
+
+constexpr uint32_t cpuUsageReadOften = 2u;
+
+constexpr uint32_t cpuUsageRead = 1u;
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_VmoBufferTable;
+
+struct VmoBuffer {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_VmoBufferTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The same VMO can be used by more than one CodecBuffer (only of the same
+ // buffer_lifetime_ordinal), but each vmo_handle must be a separate handle.
+ //
+ // The vmo field can be 0 if this is a VmoBuffer in BufferCollectionInfo_2
+ // that's at or beyond BufferCollectionInfo_2.buffer_count.
+ ::zx::vmo vmo = {};
+
+ // Offset within the VMO of the first usable byte. Must be < the VMO's size
+ // in bytes, and leave sufficient room for BufferMemorySettings.size_bytes
+ // before the end of the VMO.
+ uint64_t vmo_usable_start = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenDuplicateRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenDuplicateResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionTokenCloseResponseTable;
+
+// A BufferCollectionToken is not a BufferCollection, but rather a way to
+// identify a potential shared BufferCollection prior to the BufferCollection
+// being allocated.
+//
+// We use a channel for the BufferCollectionToken instead of a single eventpair
+// (pair) because this way we can detect error conditions like a participant
+// dying mid-create.
+class BufferCollectionToken final {
+ BufferCollectionToken() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.sysmem.BufferCollectionToken";
+
+ struct DuplicateRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t rights_attenuation_mask;
+ ::zx::channel token_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionTokenDuplicateRequestTable;
+ 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 SyncResponse = ::fidl::AnyZeroArgMessage;
+ using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Duplicate_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Duplicate_Impl(::zx::unowned_channel _client_end, uint32_t rights_attenuation_mask, ::zx::channel token_request);
+ ~Duplicate_Impl() = default;
+ Duplicate_Impl(Duplicate_Impl&& other) = default;
+ Duplicate_Impl& operator=(Duplicate_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Duplicate = Duplicate_Impl;
+ using Sync = Sync_Impl<SyncResponse>;
+ using Close = Close_Impl;
+ };
+
+ // 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:
+ class Duplicate_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Duplicate_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t rights_attenuation_mask, ::zx::channel token_request);
+ ~Duplicate_Impl() = default;
+ Duplicate_Impl(Duplicate_Impl&& other) = default;
+ Duplicate_Impl& operator=(Duplicate_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Duplicate = Duplicate_Impl;
+ using Sync = Sync_Impl<SyncResponse>;
+ using Close = Close_Impl;
+ };
+
+ 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_; }
+
+ // The initiator or a participant can send Duplicate() as part of creating
+ // another participant-side handle to the same logical
+ // BufferCollectionToken.
+ //
+ // This method is used to hand the logical token to all participants so all
+ // participants can provide constraints to sysmem for the overall
+ // BufferCollection to achieve the goal of allocating buffers compatible
+ // with all participants.
+ //
+ // The Duplicate() message is intentionally available only on
+ // BufferCollectionToken not BufferCollection.
+ //
+ // The token is separate from BufferCollection so that participants contact
+ // sysmem directly, so that participants are only trusting their environment
+ // for who sysmem is (fake token mitigation), not an initiator. Only after
+ // successful BindSharedCollection does a participant know that the token
+ // was a real sysmem token. In contrast, if we had Duplicate() directly on
+ // BufferCollection, an initiator could attempt to serve the
+ // BufferCollection channel itself, which would allow for some problematic
+ // possibilities.
+ //
+ // All the BufferCollectionToken channels of a logical token must be turned
+ // in via BindSharedCollection() for a BufferCollection to be successfully
+ // created. Else the BufferCollection channel will close.
+ //
+ // When a client calls BindSharedCollection() to turn in a
+ // BufferCollectionToken, the server will process all Duplicate() messages
+ // before closing down the BufferCollectionToken. This allows the client
+ // to Duplicate() and immediately turn in the BufferCollectionToken using
+ // BindSharedCollection, then later transfer the client end of token_request
+ // to another participant - the server will notice the existence of the
+ // token_request before considering this BufferCollectionToken fully closed.
+ //
+ // `rights_attenuation_mask` rights bits that are zero in this mask will be
+ // absent in the buffer VMO rights obtainable via the client end of
+ // token_request. This allows an initiator or intermediary participant
+ // to attenuate the rights available to a participant. This may not be the
+ // only mechanism that attenuates rights on the VMO handles obtainable via
+ // the client end of token_request. This does not allow a participant
+ // to gain rights that the participant doesn't already have. The value
+ // ZX_RIGHT_SAME_RIGHTS can be used to specify that no attenuation should
+ // be applied.
+ //
+ // `token_request` is the server end of a BufferCollectionToken channel.
+ // The client end of this channel acts as another handle to the same logical
+ // BufferCollectionToken. Typically the sender of Duplicate() will transfer
+ // the client end corresponding to collection_request to a/another
+ // participant running in a separate process, but it's also fine for the
+ // additional logical participant to be in the same process.
+ //
+ // After sending one or more Duplicate() messages, and before sending the
+ // created tokens to other participants (or to other Allocator channels),
+ // the client should send a Sync() and wait for its response. The Sync()
+ // call can be made on the token, or on the BufferCollection obtained by
+ // passing this token to BindSharedCollection(). Either will ensure that
+ // the server knows about the tokens created via Duplicate() before the
+ // other participant sends the token to the server via separate Allocator
+ // channel. If a client is using FIDL C generated code and doesn't want to
+ // block waiting for a response message, the other option is to notice
+ // arrival of the BufferCollectionEvents::OnBufferCollectionCreated() event
+ // after turning in this token for a BufferCollection.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Duplicate Duplicate(uint32_t rights_attenuation_mask, ::zx::channel token_request);
+
+ // The initiator or a participant can send Duplicate() as part of creating
+ // another participant-side handle to the same logical
+ // BufferCollectionToken.
+ //
+ // This method is used to hand the logical token to all participants so all
+ // participants can provide constraints to sysmem for the overall
+ // BufferCollection to achieve the goal of allocating buffers compatible
+ // with all participants.
+ //
+ // The Duplicate() message is intentionally available only on
+ // BufferCollectionToken not BufferCollection.
+ //
+ // The token is separate from BufferCollection so that participants contact
+ // sysmem directly, so that participants are only trusting their environment
+ // for who sysmem is (fake token mitigation), not an initiator. Only after
+ // successful BindSharedCollection does a participant know that the token
+ // was a real sysmem token. In contrast, if we had Duplicate() directly on
+ // BufferCollection, an initiator could attempt to serve the
+ // BufferCollection channel itself, which would allow for some problematic
+ // possibilities.
+ //
+ // All the BufferCollectionToken channels of a logical token must be turned
+ // in via BindSharedCollection() for a BufferCollection to be successfully
+ // created. Else the BufferCollection channel will close.
+ //
+ // When a client calls BindSharedCollection() to turn in a
+ // BufferCollectionToken, the server will process all Duplicate() messages
+ // before closing down the BufferCollectionToken. This allows the client
+ // to Duplicate() and immediately turn in the BufferCollectionToken using
+ // BindSharedCollection, then later transfer the client end of token_request
+ // to another participant - the server will notice the existence of the
+ // token_request before considering this BufferCollectionToken fully closed.
+ //
+ // `rights_attenuation_mask` rights bits that are zero in this mask will be
+ // absent in the buffer VMO rights obtainable via the client end of
+ // token_request. This allows an initiator or intermediary participant
+ // to attenuate the rights available to a participant. This may not be the
+ // only mechanism that attenuates rights on the VMO handles obtainable via
+ // the client end of token_request. This does not allow a participant
+ // to gain rights that the participant doesn't already have. The value
+ // ZX_RIGHT_SAME_RIGHTS can be used to specify that no attenuation should
+ // be applied.
+ //
+ // `token_request` is the server end of a BufferCollectionToken channel.
+ // The client end of this channel acts as another handle to the same logical
+ // BufferCollectionToken. Typically the sender of Duplicate() will transfer
+ // the client end corresponding to collection_request to a/another
+ // participant running in a separate process, but it's also fine for the
+ // additional logical participant to be in the same process.
+ //
+ // After sending one or more Duplicate() messages, and before sending the
+ // created tokens to other participants (or to other Allocator channels),
+ // the client should send a Sync() and wait for its response. The Sync()
+ // call can be made on the token, or on the BufferCollection obtained by
+ // passing this token to BindSharedCollection(). Either will ensure that
+ // the server knows about the tokens created via Duplicate() before the
+ // other participant sends the token to the server via separate Allocator
+ // channel. If a client is using FIDL C generated code and doesn't want to
+ // block waiting for a response message, the other option is to notice
+ // arrival of the BufferCollectionEvents::OnBufferCollectionCreated() event
+ // after turning in this token for a BufferCollection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Duplicate Duplicate(::fidl::BytePart _request_buffer, uint32_t rights_attenuation_mask, ::zx::channel token_request);
+
+ // Ensure that previous Duplicate() messages have been received server side,
+ // so that it's safe to send the client end of token_request to another
+ // participant knowing the server will recognize the token when it's sent
+ // into BindSharedCollection by the other participant.
+ //
+ // Other options include waiting for each Duplicate() to complete
+ // individually, or calling Sync() on BufferCollection after this token has
+ // been turned in via BindSharedCollection(), or noticing arrival of
+ // BufferCollectionEvents::OnDuplicatedTokensKnownByServer().
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+
+ // Normally a participant will convert the token into a BufferCollection
+ // view, but a particpant is also free to Close() the token (and then close
+ // the channel immediately or shortly later in response to server closing
+ // its end), which avoids causing LogicalBufferCollection failure.
+ // Normally an unexpected token channel close will cause
+ // LogicalBufferCollection failure.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ 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:
+
+ // The initiator or a participant can send Duplicate() as part of creating
+ // another participant-side handle to the same logical
+ // BufferCollectionToken.
+ //
+ // This method is used to hand the logical token to all participants so all
+ // participants can provide constraints to sysmem for the overall
+ // BufferCollection to achieve the goal of allocating buffers compatible
+ // with all participants.
+ //
+ // The Duplicate() message is intentionally available only on
+ // BufferCollectionToken not BufferCollection.
+ //
+ // The token is separate from BufferCollection so that participants contact
+ // sysmem directly, so that participants are only trusting their environment
+ // for who sysmem is (fake token mitigation), not an initiator. Only after
+ // successful BindSharedCollection does a participant know that the token
+ // was a real sysmem token. In contrast, if we had Duplicate() directly on
+ // BufferCollection, an initiator could attempt to serve the
+ // BufferCollection channel itself, which would allow for some problematic
+ // possibilities.
+ //
+ // All the BufferCollectionToken channels of a logical token must be turned
+ // in via BindSharedCollection() for a BufferCollection to be successfully
+ // created. Else the BufferCollection channel will close.
+ //
+ // When a client calls BindSharedCollection() to turn in a
+ // BufferCollectionToken, the server will process all Duplicate() messages
+ // before closing down the BufferCollectionToken. This allows the client
+ // to Duplicate() and immediately turn in the BufferCollectionToken using
+ // BindSharedCollection, then later transfer the client end of token_request
+ // to another participant - the server will notice the existence of the
+ // token_request before considering this BufferCollectionToken fully closed.
+ //
+ // `rights_attenuation_mask` rights bits that are zero in this mask will be
+ // absent in the buffer VMO rights obtainable via the client end of
+ // token_request. This allows an initiator or intermediary participant
+ // to attenuate the rights available to a participant. This may not be the
+ // only mechanism that attenuates rights on the VMO handles obtainable via
+ // the client end of token_request. This does not allow a participant
+ // to gain rights that the participant doesn't already have. The value
+ // ZX_RIGHT_SAME_RIGHTS can be used to specify that no attenuation should
+ // be applied.
+ //
+ // `token_request` is the server end of a BufferCollectionToken channel.
+ // The client end of this channel acts as another handle to the same logical
+ // BufferCollectionToken. Typically the sender of Duplicate() will transfer
+ // the client end corresponding to collection_request to a/another
+ // participant running in a separate process, but it's also fine for the
+ // additional logical participant to be in the same process.
+ //
+ // After sending one or more Duplicate() messages, and before sending the
+ // created tokens to other participants (or to other Allocator channels),
+ // the client should send a Sync() and wait for its response. The Sync()
+ // call can be made on the token, or on the BufferCollection obtained by
+ // passing this token to BindSharedCollection(). Either will ensure that
+ // the server knows about the tokens created via Duplicate() before the
+ // other participant sends the token to the server via separate Allocator
+ // channel. If a client is using FIDL C generated code and doesn't want to
+ // block waiting for a response message, the other option is to notice
+ // arrival of the BufferCollectionEvents::OnBufferCollectionCreated() event
+ // after turning in this token for a BufferCollection.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Duplicate Duplicate(::zx::unowned_channel _client_end, uint32_t rights_attenuation_mask, ::zx::channel token_request);
+
+ // The initiator or a participant can send Duplicate() as part of creating
+ // another participant-side handle to the same logical
+ // BufferCollectionToken.
+ //
+ // This method is used to hand the logical token to all participants so all
+ // participants can provide constraints to sysmem for the overall
+ // BufferCollection to achieve the goal of allocating buffers compatible
+ // with all participants.
+ //
+ // The Duplicate() message is intentionally available only on
+ // BufferCollectionToken not BufferCollection.
+ //
+ // The token is separate from BufferCollection so that participants contact
+ // sysmem directly, so that participants are only trusting their environment
+ // for who sysmem is (fake token mitigation), not an initiator. Only after
+ // successful BindSharedCollection does a participant know that the token
+ // was a real sysmem token. In contrast, if we had Duplicate() directly on
+ // BufferCollection, an initiator could attempt to serve the
+ // BufferCollection channel itself, which would allow for some problematic
+ // possibilities.
+ //
+ // All the BufferCollectionToken channels of a logical token must be turned
+ // in via BindSharedCollection() for a BufferCollection to be successfully
+ // created. Else the BufferCollection channel will close.
+ //
+ // When a client calls BindSharedCollection() to turn in a
+ // BufferCollectionToken, the server will process all Duplicate() messages
+ // before closing down the BufferCollectionToken. This allows the client
+ // to Duplicate() and immediately turn in the BufferCollectionToken using
+ // BindSharedCollection, then later transfer the client end of token_request
+ // to another participant - the server will notice the existence of the
+ // token_request before considering this BufferCollectionToken fully closed.
+ //
+ // `rights_attenuation_mask` rights bits that are zero in this mask will be
+ // absent in the buffer VMO rights obtainable via the client end of
+ // token_request. This allows an initiator or intermediary participant
+ // to attenuate the rights available to a participant. This may not be the
+ // only mechanism that attenuates rights on the VMO handles obtainable via
+ // the client end of token_request. This does not allow a participant
+ // to gain rights that the participant doesn't already have. The value
+ // ZX_RIGHT_SAME_RIGHTS can be used to specify that no attenuation should
+ // be applied.
+ //
+ // `token_request` is the server end of a BufferCollectionToken channel.
+ // The client end of this channel acts as another handle to the same logical
+ // BufferCollectionToken. Typically the sender of Duplicate() will transfer
+ // the client end corresponding to collection_request to a/another
+ // participant running in a separate process, but it's also fine for the
+ // additional logical participant to be in the same process.
+ //
+ // After sending one or more Duplicate() messages, and before sending the
+ // created tokens to other participants (or to other Allocator channels),
+ // the client should send a Sync() and wait for its response. The Sync()
+ // call can be made on the token, or on the BufferCollection obtained by
+ // passing this token to BindSharedCollection(). Either will ensure that
+ // the server knows about the tokens created via Duplicate() before the
+ // other participant sends the token to the server via separate Allocator
+ // channel. If a client is using FIDL C generated code and doesn't want to
+ // block waiting for a response message, the other option is to notice
+ // arrival of the BufferCollectionEvents::OnBufferCollectionCreated() event
+ // after turning in this token for a BufferCollection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Duplicate Duplicate(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t rights_attenuation_mask, ::zx::channel token_request);
+
+ // Ensure that previous Duplicate() messages have been received server side,
+ // so that it's safe to send the client end of token_request to another
+ // participant knowing the server will recognize the token when it's sent
+ // into BindSharedCollection by the other participant.
+ //
+ // Other options include waiting for each Duplicate() to complete
+ // individually, or calling Sync() on BufferCollection after this token has
+ // been turned in via BindSharedCollection(), or noticing arrival of
+ // BufferCollectionEvents::OnDuplicatedTokensKnownByServer().
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+
+ // Normally a participant will convert the token into a BufferCollection
+ // view, but a particpant is also free to Close() the token (and then close
+ // the channel immediately or shortly later in response to server closing
+ // its end), which avoids causing LogicalBufferCollection failure.
+ // Normally an unexpected token channel close will cause
+ // LogicalBufferCollection failure.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // The initiator or a participant can send Duplicate() as part of creating
+ // another participant-side handle to the same logical
+ // BufferCollectionToken.
+ //
+ // This method is used to hand the logical token to all participants so all
+ // participants can provide constraints to sysmem for the overall
+ // BufferCollection to achieve the goal of allocating buffers compatible
+ // with all participants.
+ //
+ // The Duplicate() message is intentionally available only on
+ // BufferCollectionToken not BufferCollection.
+ //
+ // The token is separate from BufferCollection so that participants contact
+ // sysmem directly, so that participants are only trusting their environment
+ // for who sysmem is (fake token mitigation), not an initiator. Only after
+ // successful BindSharedCollection does a participant know that the token
+ // was a real sysmem token. In contrast, if we had Duplicate() directly on
+ // BufferCollection, an initiator could attempt to serve the
+ // BufferCollection channel itself, which would allow for some problematic
+ // possibilities.
+ //
+ // All the BufferCollectionToken channels of a logical token must be turned
+ // in via BindSharedCollection() for a BufferCollection to be successfully
+ // created. Else the BufferCollection channel will close.
+ //
+ // When a client calls BindSharedCollection() to turn in a
+ // BufferCollectionToken, the server will process all Duplicate() messages
+ // before closing down the BufferCollectionToken. This allows the client
+ // to Duplicate() and immediately turn in the BufferCollectionToken using
+ // BindSharedCollection, then later transfer the client end of token_request
+ // to another participant - the server will notice the existence of the
+ // token_request before considering this BufferCollectionToken fully closed.
+ //
+ // `rights_attenuation_mask` rights bits that are zero in this mask will be
+ // absent in the buffer VMO rights obtainable via the client end of
+ // token_request. This allows an initiator or intermediary participant
+ // to attenuate the rights available to a participant. This may not be the
+ // only mechanism that attenuates rights on the VMO handles obtainable via
+ // the client end of token_request. This does not allow a participant
+ // to gain rights that the participant doesn't already have. The value
+ // ZX_RIGHT_SAME_RIGHTS can be used to specify that no attenuation should
+ // be applied.
+ //
+ // `token_request` is the server end of a BufferCollectionToken channel.
+ // The client end of this channel acts as another handle to the same logical
+ // BufferCollectionToken. Typically the sender of Duplicate() will transfer
+ // the client end corresponding to collection_request to a/another
+ // participant running in a separate process, but it's also fine for the
+ // additional logical participant to be in the same process.
+ //
+ // After sending one or more Duplicate() messages, and before sending the
+ // created tokens to other participants (or to other Allocator channels),
+ // the client should send a Sync() and wait for its response. The Sync()
+ // call can be made on the token, or on the BufferCollection obtained by
+ // passing this token to BindSharedCollection(). Either will ensure that
+ // the server knows about the tokens created via Duplicate() before the
+ // other participant sends the token to the server via separate Allocator
+ // channel. If a client is using FIDL C generated code and doesn't want to
+ // block waiting for a response message, the other option is to notice
+ // arrival of the BufferCollectionEvents::OnBufferCollectionCreated() event
+ // after turning in this token for a BufferCollection.
+ static ::fidl::internal::StatusAndError Duplicate(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DuplicateRequest> params);
+
+ // Ensure that previous Duplicate() messages have been received server side,
+ // so that it's safe to send the client end of token_request to another
+ // participant knowing the server will recognize the token when it's sent
+ // into BindSharedCollection by the other participant.
+ //
+ // Other options include waiting for each Duplicate() to complete
+ // individually, or calling Sync() on BufferCollection after this token has
+ // been turned in via BindSharedCollection(), or noticing arrival of
+ // BufferCollectionEvents::OnDuplicatedTokensKnownByServer().
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Normally a participant will convert the token into a BufferCollection
+ // view, but a particpant is also free to Close() the token (and then close
+ // the channel immediately or shortly later in response to server closing
+ // its end), which avoids causing LogicalBufferCollection failure.
+ // Normally an unexpected token channel close will cause
+ // LogicalBufferCollection failure.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = BufferCollectionToken;
+ using _Base = ::fidl::CompleterBase;
+
+ using DuplicateCompleter = ::fidl::Completer<>;
+
+ virtual void Duplicate(uint32_t rights_attenuation_mask, ::zx::channel token_request, DuplicateCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::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 DuplicateRequest(const ::fidl::DecodedMessage<BufferCollectionToken::DuplicateRequest>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<BufferCollectionToken::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<BufferCollectionToken::SyncResponse>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<BufferCollectionToken::CloseRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapAllocateVmoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapAllocateVmoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapCreateResourceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapCreateResourceResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapDestroyResourceRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_HeapDestroyResourceResponseTable;
+
+// Manages resources on a specific sysmem heap.
+//
+// Needs Layout = "Simple" because used with "FIDL Simple C Bindings".
+class Heap final {
+ Heap() = delete;
+ public:
+
+ struct AllocateVmoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ ::zx::vmo vmo;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_HeapAllocateVmoResponseTable;
+ 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;
+ };
+ struct AllocateVmoRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t size;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_HeapAllocateVmoRequestTable;
+ 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 = AllocateVmoResponse;
+ };
+
+ struct CreateResourceResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t s;
+ uint64_t id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_HeapCreateResourceResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ 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 CreateResourceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::vmo vmo;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_HeapCreateResourceRequestTable;
+ 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 = CreateResourceResponse;
+ };
+
+ using DestroyResourceResponse = ::fidl::AnyZeroArgMessage;
+ struct DestroyResourceRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_HeapDestroyResourceRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class AllocateVmo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ AllocateVmo_Impl(::zx::unowned_channel _client_end, uint64_t size);
+ ~AllocateVmo_Impl() = default;
+ AllocateVmo_Impl(AllocateVmo_Impl&& other) = default;
+ AllocateVmo_Impl& operator=(AllocateVmo_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 CreateResource_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CreateResource_Impl(::zx::unowned_channel _client_end, ::zx::vmo vmo);
+ ~CreateResource_Impl() = default;
+ CreateResource_Impl(CreateResource_Impl&& other) = default;
+ CreateResource_Impl& operator=(CreateResource_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 DestroyResource_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ DestroyResource_Impl(::zx::unowned_channel _client_end, uint64_t id);
+ ~DestroyResource_Impl() = default;
+ DestroyResource_Impl(DestroyResource_Impl&& other) = default;
+ DestroyResource_Impl& operator=(DestroyResource_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 AllocateVmo = AllocateVmo_Impl<AllocateVmoResponse>;
+ using CreateResource = CreateResource_Impl<CreateResourceResponse>;
+ using DestroyResource = DestroyResource_Impl<DestroyResourceResponse>;
+ };
+
+ // 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 AllocateVmo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ AllocateVmo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t size, ::fidl::BytePart _response_buffer);
+ ~AllocateVmo_Impl() = default;
+ AllocateVmo_Impl(AllocateVmo_Impl&& other) = default;
+ AllocateVmo_Impl& operator=(AllocateVmo_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 CreateResource_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CreateResource_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer);
+ ~CreateResource_Impl() = default;
+ CreateResource_Impl(CreateResource_Impl&& other) = default;
+ CreateResource_Impl& operator=(CreateResource_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 DestroyResource_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ DestroyResource_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t id, ::fidl::BytePart _response_buffer);
+ ~DestroyResource_Impl() = default;
+ DestroyResource_Impl(DestroyResource_Impl&& other) = default;
+ DestroyResource_Impl& operator=(DestroyResource_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 AllocateVmo = AllocateVmo_Impl<AllocateVmoResponse>;
+ using CreateResource = CreateResource_Impl<CreateResourceResponse>;
+ using DestroyResource = DestroyResource_Impl<DestroyResourceResponse>;
+ };
+
+ 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_; }
+
+ // Request a new memory allocation of `size` on heap.
+ // For heaps which don't permit CPU access to the buffer data, this
+ // will create a VMO with an official size, but which never has any
+ // physical pages. For such heaps, the VMO is effectively used as
+ // an opaque buffer identifier.
+ //
+ // Heaps should defer allocation of any associated resources until
+ // CreateResource(), because the caller of AllocateVmo() may simply
+ // delete the returned VMO with no further notification to the heap.
+ // In contrast, after CreateResource(), the caller guarantees that
+ // DestroyResource() or heap channel closure will occur.
+ //
+ // The caller guarantees that CreateResource() will be called prior
+ // to the returned VMO or any associated child VMO being used.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AllocateVmo AllocateVmo(uint64_t size);
+
+ // Request a new memory allocation of `size` on heap.
+ // For heaps which don't permit CPU access to the buffer data, this
+ // will create a VMO with an official size, but which never has any
+ // physical pages. For such heaps, the VMO is effectively used as
+ // an opaque buffer identifier.
+ //
+ // Heaps should defer allocation of any associated resources until
+ // CreateResource(), because the caller of AllocateVmo() may simply
+ // delete the returned VMO with no further notification to the heap.
+ // In contrast, after CreateResource(), the caller guarantees that
+ // DestroyResource() or heap channel closure will occur.
+ //
+ // The caller guarantees that CreateResource() will be called prior
+ // to the returned VMO or any associated child VMO being used.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AllocateVmo AllocateVmo(::fidl::BytePart _request_buffer, uint64_t size, ::fidl::BytePart _response_buffer);
+
+ // Create resources and associate heap-specific resources with the
+ // passed-in VMO. Resources can be hardware specific and their
+ // lifetime don't have to be tied to `vmo`. `vmo` must be a VMO
+ // (or a direct or indirect child of a VMO) acquired through a call
+ // to AllocateVmo method above. If the passed-in vmo is a child VMO,
+ // its size must match the size of the parent VMO created by
+ // AllocateVmo(). For heaps that permit CPU access, the passed-in
+ // VMO must not have a copy-on-write relationship with the parent
+ // VMO, but rather a pass-through relationship. Successful return
+ // status indicate that Heap has established a mapping between
+ // VMO and hardware specific resources.
+ //
+ // The returned id must be passed to DestroyResource() later when
+ // resources associated with VMO are no longer needed, unless the
+ // heap channel closes first.
+ //
+ // The heap must not own/keep a handle to VMO, or any derived child
+ // VMO, or any VMAR mapping to VMO, as any of those would keep VMO
+ // alive beyond all sysmem participant usages of the vmo; instead
+ // the heap can get the vmo's koid for the heap's mapping.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CreateResource CreateResource(::zx::vmo vmo);
+
+ // Create resources and associate heap-specific resources with the
+ // passed-in VMO. Resources can be hardware specific and their
+ // lifetime don't have to be tied to `vmo`. `vmo` must be a VMO
+ // (or a direct or indirect child of a VMO) acquired through a call
+ // to AllocateVmo method above. If the passed-in vmo is a child VMO,
+ // its size must match the size of the parent VMO created by
+ // AllocateVmo(). For heaps that permit CPU access, the passed-in
+ // VMO must not have a copy-on-write relationship with the parent
+ // VMO, but rather a pass-through relationship. Successful return
+ // status indicate that Heap has established a mapping between
+ // VMO and hardware specific resources.
+ //
+ // The returned id must be passed to DestroyResource() later when
+ // resources associated with VMO are no longer needed, unless the
+ // heap channel closes first.
+ //
+ // The heap must not own/keep a handle to VMO, or any derived child
+ // VMO, or any VMAR mapping to VMO, as any of those would keep VMO
+ // alive beyond all sysmem participant usages of the vmo; instead
+ // the heap can get the vmo's koid for the heap's mapping.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CreateResource CreateResource(::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer);
+
+ // Destroy previously created resources.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::DestroyResource DestroyResource(uint64_t id);
+
+ // Destroy previously created resources.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::DestroyResource DestroyResource(::fidl::BytePart _request_buffer, uint64_t id, ::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:
+
+ // Request a new memory allocation of `size` on heap.
+ // For heaps which don't permit CPU access to the buffer data, this
+ // will create a VMO with an official size, but which never has any
+ // physical pages. For such heaps, the VMO is effectively used as
+ // an opaque buffer identifier.
+ //
+ // Heaps should defer allocation of any associated resources until
+ // CreateResource(), because the caller of AllocateVmo() may simply
+ // delete the returned VMO with no further notification to the heap.
+ // In contrast, after CreateResource(), the caller guarantees that
+ // DestroyResource() or heap channel closure will occur.
+ //
+ // The caller guarantees that CreateResource() will be called prior
+ // to the returned VMO or any associated child VMO being used.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AllocateVmo AllocateVmo(::zx::unowned_channel _client_end, uint64_t size);
+
+ // Request a new memory allocation of `size` on heap.
+ // For heaps which don't permit CPU access to the buffer data, this
+ // will create a VMO with an official size, but which never has any
+ // physical pages. For such heaps, the VMO is effectively used as
+ // an opaque buffer identifier.
+ //
+ // Heaps should defer allocation of any associated resources until
+ // CreateResource(), because the caller of AllocateVmo() may simply
+ // delete the returned VMO with no further notification to the heap.
+ // In contrast, after CreateResource(), the caller guarantees that
+ // DestroyResource() or heap channel closure will occur.
+ //
+ // The caller guarantees that CreateResource() will be called prior
+ // to the returned VMO or any associated child VMO being used.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AllocateVmo AllocateVmo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t size, ::fidl::BytePart _response_buffer);
+
+ // Create resources and associate heap-specific resources with the
+ // passed-in VMO. Resources can be hardware specific and their
+ // lifetime don't have to be tied to `vmo`. `vmo` must be a VMO
+ // (or a direct or indirect child of a VMO) acquired through a call
+ // to AllocateVmo method above. If the passed-in vmo is a child VMO,
+ // its size must match the size of the parent VMO created by
+ // AllocateVmo(). For heaps that permit CPU access, the passed-in
+ // VMO must not have a copy-on-write relationship with the parent
+ // VMO, but rather a pass-through relationship. Successful return
+ // status indicate that Heap has established a mapping between
+ // VMO and hardware specific resources.
+ //
+ // The returned id must be passed to DestroyResource() later when
+ // resources associated with VMO are no longer needed, unless the
+ // heap channel closes first.
+ //
+ // The heap must not own/keep a handle to VMO, or any derived child
+ // VMO, or any VMAR mapping to VMO, as any of those would keep VMO
+ // alive beyond all sysmem participant usages of the vmo; instead
+ // the heap can get the vmo's koid for the heap's mapping.
+ // Allocates 56 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CreateResource CreateResource(::zx::unowned_channel _client_end, ::zx::vmo vmo);
+
+ // Create resources and associate heap-specific resources with the
+ // passed-in VMO. Resources can be hardware specific and their
+ // lifetime don't have to be tied to `vmo`. `vmo` must be a VMO
+ // (or a direct or indirect child of a VMO) acquired through a call
+ // to AllocateVmo method above. If the passed-in vmo is a child VMO,
+ // its size must match the size of the parent VMO created by
+ // AllocateVmo(). For heaps that permit CPU access, the passed-in
+ // VMO must not have a copy-on-write relationship with the parent
+ // VMO, but rather a pass-through relationship. Successful return
+ // status indicate that Heap has established a mapping between
+ // VMO and hardware specific resources.
+ //
+ // The returned id must be passed to DestroyResource() later when
+ // resources associated with VMO are no longer needed, unless the
+ // heap channel closes first.
+ //
+ // The heap must not own/keep a handle to VMO, or any derived child
+ // VMO, or any VMAR mapping to VMO, as any of those would keep VMO
+ // alive beyond all sysmem participant usages of the vmo; instead
+ // the heap can get the vmo's koid for the heap's mapping.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CreateResource CreateResource(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::vmo vmo, ::fidl::BytePart _response_buffer);
+
+ // Destroy previously created resources.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::DestroyResource DestroyResource(::zx::unowned_channel _client_end, uint64_t id);
+
+ // Destroy previously created resources.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::DestroyResource DestroyResource(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t id, ::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:
+
+ // Request a new memory allocation of `size` on heap.
+ // For heaps which don't permit CPU access to the buffer data, this
+ // will create a VMO with an official size, but which never has any
+ // physical pages. For such heaps, the VMO is effectively used as
+ // an opaque buffer identifier.
+ //
+ // Heaps should defer allocation of any associated resources until
+ // CreateResource(), because the caller of AllocateVmo() may simply
+ // delete the returned VMO with no further notification to the heap.
+ // In contrast, after CreateResource(), the caller guarantees that
+ // DestroyResource() or heap channel closure will occur.
+ //
+ // The caller guarantees that CreateResource() will be called prior
+ // to the returned VMO or any associated child VMO being used.
+ static ::fidl::DecodeResult<AllocateVmoResponse> AllocateVmo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateVmoRequest> params, ::fidl::BytePart response_buffer);
+
+ // Create resources and associate heap-specific resources with the
+ // passed-in VMO. Resources can be hardware specific and their
+ // lifetime don't have to be tied to `vmo`. `vmo` must be a VMO
+ // (or a direct or indirect child of a VMO) acquired through a call
+ // to AllocateVmo method above. If the passed-in vmo is a child VMO,
+ // its size must match the size of the parent VMO created by
+ // AllocateVmo(). For heaps that permit CPU access, the passed-in
+ // VMO must not have a copy-on-write relationship with the parent
+ // VMO, but rather a pass-through relationship. Successful return
+ // status indicate that Heap has established a mapping between
+ // VMO and hardware specific resources.
+ //
+ // The returned id must be passed to DestroyResource() later when
+ // resources associated with VMO are no longer needed, unless the
+ // heap channel closes first.
+ //
+ // The heap must not own/keep a handle to VMO, or any derived child
+ // VMO, or any VMAR mapping to VMO, as any of those would keep VMO
+ // alive beyond all sysmem participant usages of the vmo; instead
+ // the heap can get the vmo's koid for the heap's mapping.
+ static ::fidl::DecodeResult<CreateResourceResponse> CreateResource(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CreateResourceRequest> params, ::fidl::BytePart response_buffer);
+
+ // Destroy previously created resources.
+ static ::fidl::DecodeResult<DestroyResourceResponse> DestroyResource(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<DestroyResourceRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Heap;
+ using _Base = ::fidl::CompleterBase;
+
+ class AllocateVmoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, ::zx::vmo vmo);
+ void Reply(::fidl::BytePart _buffer, int32_t s, ::zx::vmo vmo);
+ void Reply(::fidl::DecodedMessage<AllocateVmoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using AllocateVmoCompleter = ::fidl::Completer<AllocateVmoCompleterBase>;
+
+ virtual void AllocateVmo(uint64_t size, AllocateVmoCompleter::Sync _completer) = 0;
+
+ class CreateResourceCompleterBase : public _Base {
+ public:
+ void Reply(int32_t s, uint64_t id);
+ void Reply(::fidl::BytePart _buffer, int32_t s, uint64_t id);
+ void Reply(::fidl::DecodedMessage<CreateResourceResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CreateResourceCompleter = ::fidl::Completer<CreateResourceCompleterBase>;
+
+ virtual void CreateResource(::zx::vmo vmo, CreateResourceCompleter::Sync _completer) = 0;
+
+ class DestroyResourceCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using DestroyResourceCompleter = ::fidl::Completer<DestroyResourceCompleterBase>;
+
+ virtual void DestroyResource(uint64_t id, DestroyResourceCompleter::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 AllocateVmoRequest(const ::fidl::DecodedMessage<Heap::AllocateVmoRequest>& _msg);
+ static void AllocateVmoResponse(const ::fidl::DecodedMessage<Heap::AllocateVmoResponse>& _msg);
+ static void CreateResourceRequest(const ::fidl::DecodedMessage<Heap::CreateResourceRequest>& _msg);
+ static void CreateResourceResponse(const ::fidl::DecodedMessage<Heap::CreateResourceResponse>& _msg);
+ static void DestroyResourceRequest(const ::fidl::DecodedMessage<Heap::DestroyResourceRequest>& _msg);
+ static void DestroyResourceResponse(const ::fidl::DecodedMessage<Heap::DestroyResourceResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_DriverConnectorConnectRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_DriverConnectorConnectResponseTable;
+
+// Once a channel with this interface is established to a driver (typically in
+// advance), this interface allows asynchronously sending the server end of an
+// Allocator channel which will be served by the driver.
+//
+// For now, the only FIDL interface directly served via normal devhost FIDL
+// dispatching code by the sysmem driver is this interface. Other sysmem
+// interfaces are served by separate dispatching code primarily because we want
+// to be able to establish channels async by sending the server channel toward
+// the driver without needing a round-trip open and without managing the channel
+// as a file descriptor.
+//
+// A secondary current reason tracked by ZX-3091 is that the current devhost
+// dispatching code doesn't permit async processing of requests, which we want
+// for proper functionining of at least the BufferCollection interface since
+// that interface has requests that don't complete until the devhost has
+// constraints from other participants.
+class DriverConnector final {
+ DriverConnector() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.sysmem.DriverConnector";
+
+ struct ConnectRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel allocator_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_DriverConnectorConnectRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Connect_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::zx::channel allocator_request);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Connect = Connect_Impl;
+ };
+
+ // 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:
+ class Connect_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Connect_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel allocator_request);
+ ~Connect_Impl() = default;
+ Connect_Impl(Connect_Impl&& other) = default;
+ Connect_Impl& operator=(Connect_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using Connect = Connect_Impl;
+ };
+
+ 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_; }
+
+ // This one-way message sends in the server end of an Allocator channel.
+ //
+ // `allocator_request` will be served by the sysmem driver (or the channel
+ // will close).
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Connect Connect(::zx::channel allocator_request);
+
+ // This one-way message sends in the server end of an Allocator channel.
+ //
+ // `allocator_request` will be served by the sysmem driver (or the channel
+ // will close).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Connect Connect(::fidl::BytePart _request_buffer, ::zx::channel allocator_request);
+
+ 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:
+
+ // This one-way message sends in the server end of an Allocator channel.
+ //
+ // `allocator_request` will be served by the sysmem driver (or the channel
+ // will close).
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Connect Connect(::zx::unowned_channel _client_end, ::zx::channel allocator_request);
+
+ // This one-way message sends in the server end of an Allocator channel.
+ //
+ // `allocator_request` will be served by the sysmem driver (or the channel
+ // will close).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Connect Connect(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel allocator_request);
+
+ };
+
+ // 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:
+
+ // This one-way message sends in the server end of an Allocator channel.
+ //
+ // `allocator_request` will be served by the sysmem driver (or the channel
+ // will close).
+ static ::fidl::internal::StatusAndError Connect(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConnectRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DriverConnector;
+ using _Base = ::fidl::CompleterBase;
+
+ using ConnectCompleter = ::fidl::Completer<>;
+
+ virtual void Connect(::zx::channel allocator_request, ConnectCompleter::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 ConnectRequest(const ::fidl::DecodedMessage<DriverConnector::ConnectRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorAllocateNonSharedCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorAllocateNonSharedCollectionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorAllocateSharedCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorAllocateSharedCollectionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorBindSharedCollectionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_AllocatorBindSharedCollectionResponseTable;
+
+// Allocates system memory buffers.
+//
+class Allocator final {
+ Allocator() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.sysmem.Allocator";
+
+ struct AllocateNonSharedCollectionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel collection;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_AllocatorAllocateNonSharedCollectionRequestTable;
+ 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;
+ };
+
+ struct AllocateSharedCollectionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel token_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_AllocatorAllocateSharedCollectionRequestTable;
+ 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;
+ };
+
+ struct BindSharedCollectionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel token;
+ ::zx::channel buffer_collection_request;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_AllocatorBindSharedCollectionRequestTable;
+ static constexpr uint32_t MaxNumHandles = 2;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class AllocateNonSharedCollection_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AllocateNonSharedCollection_Impl(::zx::unowned_channel _client_end, ::zx::channel collection);
+ ~AllocateNonSharedCollection_Impl() = default;
+ AllocateNonSharedCollection_Impl(AllocateNonSharedCollection_Impl&& other) = default;
+ AllocateNonSharedCollection_Impl& operator=(AllocateNonSharedCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AllocateSharedCollection_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AllocateSharedCollection_Impl(::zx::unowned_channel _client_end, ::zx::channel token_request);
+ ~AllocateSharedCollection_Impl() = default;
+ AllocateSharedCollection_Impl(AllocateSharedCollection_Impl&& other) = default;
+ AllocateSharedCollection_Impl& operator=(AllocateSharedCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class BindSharedCollection_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ BindSharedCollection_Impl(::zx::unowned_channel _client_end, ::zx::channel token, ::zx::channel buffer_collection_request);
+ ~BindSharedCollection_Impl() = default;
+ BindSharedCollection_Impl(BindSharedCollection_Impl&& other) = default;
+ BindSharedCollection_Impl& operator=(BindSharedCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using AllocateNonSharedCollection = AllocateNonSharedCollection_Impl;
+ using AllocateSharedCollection = AllocateSharedCollection_Impl;
+ using BindSharedCollection = BindSharedCollection_Impl;
+ };
+
+ // 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:
+ class AllocateNonSharedCollection_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AllocateNonSharedCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel collection);
+ ~AllocateNonSharedCollection_Impl() = default;
+ AllocateNonSharedCollection_Impl(AllocateNonSharedCollection_Impl&& other) = default;
+ AllocateNonSharedCollection_Impl& operator=(AllocateNonSharedCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AllocateSharedCollection_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AllocateSharedCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel token_request);
+ ~AllocateSharedCollection_Impl() = default;
+ AllocateSharedCollection_Impl(AllocateSharedCollection_Impl&& other) = default;
+ AllocateSharedCollection_Impl& operator=(AllocateSharedCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class BindSharedCollection_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ BindSharedCollection_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel token, ::zx::channel buffer_collection_request);
+ ~BindSharedCollection_Impl() = default;
+ BindSharedCollection_Impl(BindSharedCollection_Impl&& other) = default;
+ BindSharedCollection_Impl& operator=(BindSharedCollection_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using AllocateNonSharedCollection = AllocateNonSharedCollection_Impl;
+ using AllocateSharedCollection = AllocateSharedCollection_Impl;
+ using BindSharedCollection = BindSharedCollection_Impl;
+ };
+
+ 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 a BufferCollection on behalf of a single client (aka initiator)
+ // who is also the only participant (from the point of view of sysmem).
+ //
+ // This call exists mainly for temp/testing purposes. This call skips the
+ // BufferCollectionToken stage, so there's no way to allow another
+ // participant to specify its constraints.
+ //
+ // Real clients are encouraged to use AllocateSharedCollection() instead,
+ // and to let relevant participants directly convey their own constraints to
+ // sysmem.
+ //
+ // `constraints` indicates constraints on the buffer collection, such as how
+ // many buffers to allocate, buffer size constraints, etc.
+ //
+ // `collection` is the server end of the BufferCollection FIDL channel. The
+ // client can call SetConstraints() and then WaitForBuffersAllocated() on
+ // the client end of this channel to specify constraints and then determine
+ // success/failure and get the BufferCollectionInfo_2 for the
+ // BufferCollection. The client should also keep the client end of
+ // this channel open while using the BufferCollection, and should notice
+ // when this channel closes and stop using the BufferCollection ASAP.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AllocateNonSharedCollection AllocateNonSharedCollection(::zx::channel collection);
+
+ // Allocates a BufferCollection on behalf of a single client (aka initiator)
+ // who is also the only participant (from the point of view of sysmem).
+ //
+ // This call exists mainly for temp/testing purposes. This call skips the
+ // BufferCollectionToken stage, so there's no way to allow another
+ // participant to specify its constraints.
+ //
+ // Real clients are encouraged to use AllocateSharedCollection() instead,
+ // and to let relevant participants directly convey their own constraints to
+ // sysmem.
+ //
+ // `constraints` indicates constraints on the buffer collection, such as how
+ // many buffers to allocate, buffer size constraints, etc.
+ //
+ // `collection` is the server end of the BufferCollection FIDL channel. The
+ // client can call SetConstraints() and then WaitForBuffersAllocated() on
+ // the client end of this channel to specify constraints and then determine
+ // success/failure and get the BufferCollectionInfo_2 for the
+ // BufferCollection. The client should also keep the client end of
+ // this channel open while using the BufferCollection, and should notice
+ // when this channel closes and stop using the BufferCollection ASAP.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AllocateNonSharedCollection AllocateNonSharedCollection(::fidl::BytePart _request_buffer, ::zx::channel collection);
+
+ // Creates a logical BufferCollectionToken which can be shared among
+ // participants (using BufferCollectionToken.Duplicate()), and then
+ // converted into a BufferCollection using BindSharedCollection().
+ //
+ // Success/failure to populate the BufferCollection with buffers is
+ // determined via the BufferCollection interface.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AllocateSharedCollection AllocateSharedCollection(::zx::channel token_request);
+
+ // Creates a logical BufferCollectionToken which can be shared among
+ // participants (using BufferCollectionToken.Duplicate()), and then
+ // converted into a BufferCollection using BindSharedCollection().
+ //
+ // Success/failure to populate the BufferCollection with buffers is
+ // determined via the BufferCollection interface.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AllocateSharedCollection AllocateSharedCollection(::fidl::BytePart _request_buffer, ::zx::channel token_request);
+
+ // Convert a BufferCollectionToken into a connection to the logical
+ // BufferCollection. The BufferCollection hasn't yet been populated with
+ // buffers - the participant must first also send SetConstraints() via the
+ // client end of buffer_collection.
+ //
+ // All BufferCollectionToken(s) duplicated from a logical
+ // BufferCollectionToken created via AllocateSharedCollection() must be
+ // turned in via BindSharedCollection() before the logical BufferCollection
+ // will be populated with buffers.
+ //
+ // `token` the client endpoint of a channel whose server end was sent to
+ // sysmem using AllocateSharedCollection or whose server end was sent to
+ // sysmem using BufferCollectionToken.Duplicate(). The token is being
+ // "exchanged" for a channel to the logical BufferCollection.
+ //
+ // `buffer_collection` the server end of a BufferCollection channel. The
+ // sender retains the client end as usual. The BufferCollection channel
+ // is a single participant's connection to the logical BufferCollection.
+ // There typically will be other participants with their own
+ // BufferCollection channel to the logical BufferCollection.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::BindSharedCollection BindSharedCollection(::zx::channel token, ::zx::channel buffer_collection_request);
+
+ // Convert a BufferCollectionToken into a connection to the logical
+ // BufferCollection. The BufferCollection hasn't yet been populated with
+ // buffers - the participant must first also send SetConstraints() via the
+ // client end of buffer_collection.
+ //
+ // All BufferCollectionToken(s) duplicated from a logical
+ // BufferCollectionToken created via AllocateSharedCollection() must be
+ // turned in via BindSharedCollection() before the logical BufferCollection
+ // will be populated with buffers.
+ //
+ // `token` the client endpoint of a channel whose server end was sent to
+ // sysmem using AllocateSharedCollection or whose server end was sent to
+ // sysmem using BufferCollectionToken.Duplicate(). The token is being
+ // "exchanged" for a channel to the logical BufferCollection.
+ //
+ // `buffer_collection` the server end of a BufferCollection channel. The
+ // sender retains the client end as usual. The BufferCollection channel
+ // is a single participant's connection to the logical BufferCollection.
+ // There typically will be other participants with their own
+ // BufferCollection channel to the logical BufferCollection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::BindSharedCollection BindSharedCollection(::fidl::BytePart _request_buffer, ::zx::channel token, ::zx::channel buffer_collection_request);
+
+ 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 a BufferCollection on behalf of a single client (aka initiator)
+ // who is also the only participant (from the point of view of sysmem).
+ //
+ // This call exists mainly for temp/testing purposes. This call skips the
+ // BufferCollectionToken stage, so there's no way to allow another
+ // participant to specify its constraints.
+ //
+ // Real clients are encouraged to use AllocateSharedCollection() instead,
+ // and to let relevant participants directly convey their own constraints to
+ // sysmem.
+ //
+ // `constraints` indicates constraints on the buffer collection, such as how
+ // many buffers to allocate, buffer size constraints, etc.
+ //
+ // `collection` is the server end of the BufferCollection FIDL channel. The
+ // client can call SetConstraints() and then WaitForBuffersAllocated() on
+ // the client end of this channel to specify constraints and then determine
+ // success/failure and get the BufferCollectionInfo_2 for the
+ // BufferCollection. The client should also keep the client end of
+ // this channel open while using the BufferCollection, and should notice
+ // when this channel closes and stop using the BufferCollection ASAP.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AllocateNonSharedCollection AllocateNonSharedCollection(::zx::unowned_channel _client_end, ::zx::channel collection);
+
+ // Allocates a BufferCollection on behalf of a single client (aka initiator)
+ // who is also the only participant (from the point of view of sysmem).
+ //
+ // This call exists mainly for temp/testing purposes. This call skips the
+ // BufferCollectionToken stage, so there's no way to allow another
+ // participant to specify its constraints.
+ //
+ // Real clients are encouraged to use AllocateSharedCollection() instead,
+ // and to let relevant participants directly convey their own constraints to
+ // sysmem.
+ //
+ // `constraints` indicates constraints on the buffer collection, such as how
+ // many buffers to allocate, buffer size constraints, etc.
+ //
+ // `collection` is the server end of the BufferCollection FIDL channel. The
+ // client can call SetConstraints() and then WaitForBuffersAllocated() on
+ // the client end of this channel to specify constraints and then determine
+ // success/failure and get the BufferCollectionInfo_2 for the
+ // BufferCollection. The client should also keep the client end of
+ // this channel open while using the BufferCollection, and should notice
+ // when this channel closes and stop using the BufferCollection ASAP.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AllocateNonSharedCollection AllocateNonSharedCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel collection);
+
+ // Creates a logical BufferCollectionToken which can be shared among
+ // participants (using BufferCollectionToken.Duplicate()), and then
+ // converted into a BufferCollection using BindSharedCollection().
+ //
+ // Success/failure to populate the BufferCollection with buffers is
+ // determined via the BufferCollection interface.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AllocateSharedCollection AllocateSharedCollection(::zx::unowned_channel _client_end, ::zx::channel token_request);
+
+ // Creates a logical BufferCollectionToken which can be shared among
+ // participants (using BufferCollectionToken.Duplicate()), and then
+ // converted into a BufferCollection using BindSharedCollection().
+ //
+ // Success/failure to populate the BufferCollection with buffers is
+ // determined via the BufferCollection interface.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AllocateSharedCollection AllocateSharedCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel token_request);
+
+ // Convert a BufferCollectionToken into a connection to the logical
+ // BufferCollection. The BufferCollection hasn't yet been populated with
+ // buffers - the participant must first also send SetConstraints() via the
+ // client end of buffer_collection.
+ //
+ // All BufferCollectionToken(s) duplicated from a logical
+ // BufferCollectionToken created via AllocateSharedCollection() must be
+ // turned in via BindSharedCollection() before the logical BufferCollection
+ // will be populated with buffers.
+ //
+ // `token` the client endpoint of a channel whose server end was sent to
+ // sysmem using AllocateSharedCollection or whose server end was sent to
+ // sysmem using BufferCollectionToken.Duplicate(). The token is being
+ // "exchanged" for a channel to the logical BufferCollection.
+ //
+ // `buffer_collection` the server end of a BufferCollection channel. The
+ // sender retains the client end as usual. The BufferCollection channel
+ // is a single participant's connection to the logical BufferCollection.
+ // There typically will be other participants with their own
+ // BufferCollection channel to the logical BufferCollection.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::BindSharedCollection BindSharedCollection(::zx::unowned_channel _client_end, ::zx::channel token, ::zx::channel buffer_collection_request);
+
+ // Convert a BufferCollectionToken into a connection to the logical
+ // BufferCollection. The BufferCollection hasn't yet been populated with
+ // buffers - the participant must first also send SetConstraints() via the
+ // client end of buffer_collection.
+ //
+ // All BufferCollectionToken(s) duplicated from a logical
+ // BufferCollectionToken created via AllocateSharedCollection() must be
+ // turned in via BindSharedCollection() before the logical BufferCollection
+ // will be populated with buffers.
+ //
+ // `token` the client endpoint of a channel whose server end was sent to
+ // sysmem using AllocateSharedCollection or whose server end was sent to
+ // sysmem using BufferCollectionToken.Duplicate(). The token is being
+ // "exchanged" for a channel to the logical BufferCollection.
+ //
+ // `buffer_collection` the server end of a BufferCollection channel. The
+ // sender retains the client end as usual. The BufferCollection channel
+ // is a single participant's connection to the logical BufferCollection.
+ // There typically will be other participants with their own
+ // BufferCollection channel to the logical BufferCollection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::BindSharedCollection BindSharedCollection(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel token, ::zx::channel buffer_collection_request);
+
+ };
+
+ // 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:
+
+ // Allocates a BufferCollection on behalf of a single client (aka initiator)
+ // who is also the only participant (from the point of view of sysmem).
+ //
+ // This call exists mainly for temp/testing purposes. This call skips the
+ // BufferCollectionToken stage, so there's no way to allow another
+ // participant to specify its constraints.
+ //
+ // Real clients are encouraged to use AllocateSharedCollection() instead,
+ // and to let relevant participants directly convey their own constraints to
+ // sysmem.
+ //
+ // `constraints` indicates constraints on the buffer collection, such as how
+ // many buffers to allocate, buffer size constraints, etc.
+ //
+ // `collection` is the server end of the BufferCollection FIDL channel. The
+ // client can call SetConstraints() and then WaitForBuffersAllocated() on
+ // the client end of this channel to specify constraints and then determine
+ // success/failure and get the BufferCollectionInfo_2 for the
+ // BufferCollection. The client should also keep the client end of
+ // this channel open while using the BufferCollection, and should notice
+ // when this channel closes and stop using the BufferCollection ASAP.
+ static ::fidl::internal::StatusAndError AllocateNonSharedCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateNonSharedCollectionRequest> params);
+
+ // Creates a logical BufferCollectionToken which can be shared among
+ // participants (using BufferCollectionToken.Duplicate()), and then
+ // converted into a BufferCollection using BindSharedCollection().
+ //
+ // Success/failure to populate the BufferCollection with buffers is
+ // determined via the BufferCollection interface.
+ static ::fidl::internal::StatusAndError AllocateSharedCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateSharedCollectionRequest> params);
+
+ // Convert a BufferCollectionToken into a connection to the logical
+ // BufferCollection. The BufferCollection hasn't yet been populated with
+ // buffers - the participant must first also send SetConstraints() via the
+ // client end of buffer_collection.
+ //
+ // All BufferCollectionToken(s) duplicated from a logical
+ // BufferCollectionToken created via AllocateSharedCollection() must be
+ // turned in via BindSharedCollection() before the logical BufferCollection
+ // will be populated with buffers.
+ //
+ // `token` the client endpoint of a channel whose server end was sent to
+ // sysmem using AllocateSharedCollection or whose server end was sent to
+ // sysmem using BufferCollectionToken.Duplicate(). The token is being
+ // "exchanged" for a channel to the logical BufferCollection.
+ //
+ // `buffer_collection` the server end of a BufferCollection channel. The
+ // sender retains the client end as usual. The BufferCollection channel
+ // is a single participant's connection to the logical BufferCollection.
+ // There typically will be other participants with their own
+ // BufferCollection channel to the logical BufferCollection.
+ static ::fidl::internal::StatusAndError BindSharedCollection(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<BindSharedCollectionRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Allocator;
+ using _Base = ::fidl::CompleterBase;
+
+ using AllocateNonSharedCollectionCompleter = ::fidl::Completer<>;
+
+ virtual void AllocateNonSharedCollection(::zx::channel collection, AllocateNonSharedCollectionCompleter::Sync _completer) = 0;
+
+ using AllocateSharedCollectionCompleter = ::fidl::Completer<>;
+
+ virtual void AllocateSharedCollection(::zx::channel token_request, AllocateSharedCollectionCompleter::Sync _completer) = 0;
+
+ using BindSharedCollectionCompleter = ::fidl::Completer<>;
+
+ virtual void BindSharedCollection(::zx::channel token, ::zx::channel buffer_collection_request, BindSharedCollectionCompleter::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 AllocateNonSharedCollectionRequest(const ::fidl::DecodedMessage<Allocator::AllocateNonSharedCollectionRequest>& _msg);
+ static void AllocateSharedCollectionRequest(const ::fidl::DecodedMessage<Allocator::AllocateSharedCollectionRequest>& _msg);
+ static void BindSharedCollectionRequest(const ::fidl::DecodedMessage<Allocator::BindSharedCollectionRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMem_SetPhysicalSecureHeaps_ResponseTable;
+
+struct SecureMem_SetPhysicalSecureHeaps_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SecureMem_SetPhysicalSecureHeaps_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+constexpr uint32_t MAX_HEAPS_COUNT = 32u;
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_ImagePlaneTable;
+
+struct ImagePlane {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_ImagePlaneTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Byte offset of the start of the plane from the beginning of the image.
+ uint32_t byte_offset = {};
+
+ // Stride in bytes per row.
+ // Only meaningful for linear buffer formats.
+ uint32_t bytes_per_row = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_PhysicalSecureHeapTable;
+
+struct PhysicalSecureHeap {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_PhysicalSecureHeapTable;
+ 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;
+
+ // This must be a HeapType that is secure/protected.
+ ::llcpp::fuchsia::sysmem::HeapType heap = {};
+
+ // Must be at least PAGE_SIZE aligned.
+ uint64_t physical_address = {};
+
+ // Must be at least PAGE_SIZE aligned.
+ uint64_t size_bytes = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_PhysicalSecureHeapsTable;
+
+struct PhysicalSecureHeaps {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_PhysicalSecureHeapsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 776;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Must be <= MAX_HEAPS_COUNT.
+ uint32_t heaps_count = {};
+
+ // Only the first heaps_count are meaningful. The rest are ignored.
+ ::fidl::Array<::llcpp::fuchsia::sysmem::PhysicalSecureHeap, 32> heaps = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMem_GetPhysicalSecureHeaps_ResponseTable;
+
+struct SecureMem_GetPhysicalSecureHeaps_Response {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SecureMem_GetPhysicalSecureHeaps_ResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 776;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMemGetPhysicalSecureHeapsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMemGetPhysicalSecureHeapsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMemSetPhysicalSecureHeapsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SecureMemSetPhysicalSecureHeapsResponseTable;
+
+// SecureMem
+//
+// The client is sysmem. The server is securemem driver.
+//
+// TEE - Trusted Execution Environment.
+//
+// REE - Rich Execution Environment.
+//
+// Enables sysmem to call the securemem driver to get any secure heaps
+// configured via the TEE (or via the securemem driver), and set any physical
+// secure heaps configured via sysmem.
+//
+// Presently, dynamically-allocated secure heaps are configured via sysmem, as
+// it starts quite early during boot and can successfully reserve contiguous
+// physical memory. Presently, fixed-location secure heaps are configured via
+// TEE, as the plumbing goes from the bootloader to the TEE. However, this
+// protocol intentionally doesn't care which heaps are dynamically-allocated
+// and which are fixed-location.
+class SecureMem final {
+ SecureMem() = delete;
+ public:
+
+ struct GetPhysicalSecureHeapsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SecureMemGetPhysicalSecureHeapsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 776;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetPhysicalSecureHeapsRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetPhysicalSecureHeapsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Result result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SecureMemSetPhysicalSecureHeapsResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 8;
+ static constexpr bool HasFlexibleEnvelope = false;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = true;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct SetPhysicalSecureHeapsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SecureMemSetPhysicalSecureHeapsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 792;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 792;
+ 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 = SetPhysicalSecureHeapsResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetPhysicalSecureHeaps_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetPhysicalSecureHeaps_Impl(::zx::unowned_channel _client_end);
+ ~GetPhysicalSecureHeaps_Impl() = default;
+ GetPhysicalSecureHeaps_Impl(GetPhysicalSecureHeaps_Impl&& other) = default;
+ GetPhysicalSecureHeaps_Impl& operator=(GetPhysicalSecureHeaps_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 SetPhysicalSecureHeaps_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ SetPhysicalSecureHeaps_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps);
+ ~SetPhysicalSecureHeaps_Impl() = default;
+ SetPhysicalSecureHeaps_Impl(SetPhysicalSecureHeaps_Impl&& other) = default;
+ SetPhysicalSecureHeaps_Impl& operator=(SetPhysicalSecureHeaps_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 GetPhysicalSecureHeaps = GetPhysicalSecureHeaps_Impl<GetPhysicalSecureHeapsResponse>;
+ using SetPhysicalSecureHeaps = SetPhysicalSecureHeaps_Impl<SetPhysicalSecureHeapsResponse>;
+ };
+
+ // 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 GetPhysicalSecureHeaps_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetPhysicalSecureHeaps_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetPhysicalSecureHeaps_Impl() = default;
+ GetPhysicalSecureHeaps_Impl(GetPhysicalSecureHeaps_Impl&& other) = default;
+ GetPhysicalSecureHeaps_Impl& operator=(GetPhysicalSecureHeaps_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 SetPhysicalSecureHeaps_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ SetPhysicalSecureHeaps_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps, ::fidl::BytePart _response_buffer);
+ ~SetPhysicalSecureHeaps_Impl() = default;
+ SetPhysicalSecureHeaps_Impl(SetPhysicalSecureHeaps_Impl&& other) = default;
+ SetPhysicalSecureHeaps_Impl& operator=(SetPhysicalSecureHeaps_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 GetPhysicalSecureHeaps = GetPhysicalSecureHeaps_Impl<GetPhysicalSecureHeapsResponse>;
+ using SetPhysicalSecureHeaps = SetPhysicalSecureHeaps_Impl<SetPhysicalSecureHeapsResponse>;
+ };
+
+ 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_; }
+
+ // Gets the physical address and length of any secure heap whose physical
+ // range is configured via the TEE.
+ //
+ // Presently, these will be fixed physical addresses and lengths, with the
+ // location plumbed via the TEE.
+ //
+ // This is preferred over RegisterHeap() when there isn't any special
+ // heap-specific per-VMO setup or teardown required.
+ //
+ // The physical range must be secured/protected by the TEE before the
+ // securemem driver responds to this request with success.
+ //
+ // Sysmem should only call this once. Returning zero heaps is not a
+ // failure.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once.
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetPhysicalSecureHeaps GetPhysicalSecureHeaps();
+
+ // Gets the physical address and length of any secure heap whose physical
+ // range is configured via the TEE.
+ //
+ // Presently, these will be fixed physical addresses and lengths, with the
+ // location plumbed via the TEE.
+ //
+ // This is preferred over RegisterHeap() when there isn't any special
+ // heap-specific per-VMO setup or teardown required.
+ //
+ // The physical range must be secured/protected by the TEE before the
+ // securemem driver responds to this request with success.
+ //
+ // Sysmem should only call this once. Returning zero heaps is not a
+ // failure.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once.
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetPhysicalSecureHeaps GetPhysicalSecureHeaps(::fidl::BytePart _response_buffer);
+
+ // This request from sysmem to the securemem driver lets the TEE know the
+ // physical memory address and length of any secure heap whose location is
+ // configured/established via sysmem.
+ //
+ // Only sysmem can call this because only sysmem is handed the client end
+ // of a FIDL channel serving this protocol, via RegisterSecureMem(). The
+ // securemem driver is the server end of this protocol.
+ //
+ // Presently, these physical ranges will be dynamically-allocated by sysmem
+ // early during boot.
+ //
+ // The heap ID is included in case that's relevant to the securemem driver,
+ // for more informative log messages, and for consistency with
+ // GetPhysicalSecureHeaps().
+ //
+ // The securemem driver must configure all the provided ranges as secure
+ // with the TEE before responding to this message with success.
+ //
+ // For heaps configured via sysmem, both the HeapType and heap location are
+ // configured via sysmem, and ZX_ERR_INVALID_ARGS will be the result if the
+ // securemem driver determines that the number of heaps or HeapType(s) are
+ // not what's supported by the securemem driver. Typically these aspects
+ // are essentially fixed for a given device, so this error would typically
+ // imply a configuration or plumbing problem.
+ //
+ // Sysmem should only call this once.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once
+ // * ZX_ERR_INVALID_ARGS - unexpected heap count or unexpected heap
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::SetPhysicalSecureHeaps SetPhysicalSecureHeaps(::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps);
+
+ // This request from sysmem to the securemem driver lets the TEE know the
+ // physical memory address and length of any secure heap whose location is
+ // configured/established via sysmem.
+ //
+ // Only sysmem can call this because only sysmem is handed the client end
+ // of a FIDL channel serving this protocol, via RegisterSecureMem(). The
+ // securemem driver is the server end of this protocol.
+ //
+ // Presently, these physical ranges will be dynamically-allocated by sysmem
+ // early during boot.
+ //
+ // The heap ID is included in case that's relevant to the securemem driver,
+ // for more informative log messages, and for consistency with
+ // GetPhysicalSecureHeaps().
+ //
+ // The securemem driver must configure all the provided ranges as secure
+ // with the TEE before responding to this message with success.
+ //
+ // For heaps configured via sysmem, both the HeapType and heap location are
+ // configured via sysmem, and ZX_ERR_INVALID_ARGS will be the result if the
+ // securemem driver determines that the number of heaps or HeapType(s) are
+ // not what's supported by the securemem driver. Typically these aspects
+ // are essentially fixed for a given device, so this error would typically
+ // imply a configuration or plumbing problem.
+ //
+ // Sysmem should only call this once.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once
+ // * ZX_ERR_INVALID_ARGS - unexpected heap count or unexpected heap
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetPhysicalSecureHeaps SetPhysicalSecureHeaps(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps, ::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:
+
+ // Gets the physical address and length of any secure heap whose physical
+ // range is configured via the TEE.
+ //
+ // Presently, these will be fixed physical addresses and lengths, with the
+ // location plumbed via the TEE.
+ //
+ // This is preferred over RegisterHeap() when there isn't any special
+ // heap-specific per-VMO setup or teardown required.
+ //
+ // The physical range must be secured/protected by the TEE before the
+ // securemem driver responds to this request with success.
+ //
+ // Sysmem should only call this once. Returning zero heaps is not a
+ // failure.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once.
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetPhysicalSecureHeaps GetPhysicalSecureHeaps(::zx::unowned_channel _client_end);
+
+ // Gets the physical address and length of any secure heap whose physical
+ // range is configured via the TEE.
+ //
+ // Presently, these will be fixed physical addresses and lengths, with the
+ // location plumbed via the TEE.
+ //
+ // This is preferred over RegisterHeap() when there isn't any special
+ // heap-specific per-VMO setup or teardown required.
+ //
+ // The physical range must be secured/protected by the TEE before the
+ // securemem driver responds to this request with success.
+ //
+ // Sysmem should only call this once. Returning zero heaps is not a
+ // failure.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once.
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetPhysicalSecureHeaps GetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // This request from sysmem to the securemem driver lets the TEE know the
+ // physical memory address and length of any secure heap whose location is
+ // configured/established via sysmem.
+ //
+ // Only sysmem can call this because only sysmem is handed the client end
+ // of a FIDL channel serving this protocol, via RegisterSecureMem(). The
+ // securemem driver is the server end of this protocol.
+ //
+ // Presently, these physical ranges will be dynamically-allocated by sysmem
+ // early during boot.
+ //
+ // The heap ID is included in case that's relevant to the securemem driver,
+ // for more informative log messages, and for consistency with
+ // GetPhysicalSecureHeaps().
+ //
+ // The securemem driver must configure all the provided ranges as secure
+ // with the TEE before responding to this message with success.
+ //
+ // For heaps configured via sysmem, both the HeapType and heap location are
+ // configured via sysmem, and ZX_ERR_INVALID_ARGS will be the result if the
+ // securemem driver determines that the number of heaps or HeapType(s) are
+ // not what's supported by the securemem driver. Typically these aspects
+ // are essentially fixed for a given device, so this error would typically
+ // imply a configuration or plumbing problem.
+ //
+ // Sysmem should only call this once.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once
+ // * ZX_ERR_INVALID_ARGS - unexpected heap count or unexpected heap
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ // Allocates 48 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::SetPhysicalSecureHeaps SetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps);
+
+ // This request from sysmem to the securemem driver lets the TEE know the
+ // physical memory address and length of any secure heap whose location is
+ // configured/established via sysmem.
+ //
+ // Only sysmem can call this because only sysmem is handed the client end
+ // of a FIDL channel serving this protocol, via RegisterSecureMem(). The
+ // securemem driver is the server end of this protocol.
+ //
+ // Presently, these physical ranges will be dynamically-allocated by sysmem
+ // early during boot.
+ //
+ // The heap ID is included in case that's relevant to the securemem driver,
+ // for more informative log messages, and for consistency with
+ // GetPhysicalSecureHeaps().
+ //
+ // The securemem driver must configure all the provided ranges as secure
+ // with the TEE before responding to this message with success.
+ //
+ // For heaps configured via sysmem, both the HeapType and heap location are
+ // configured via sysmem, and ZX_ERR_INVALID_ARGS will be the result if the
+ // securemem driver determines that the number of heaps or HeapType(s) are
+ // not what's supported by the securemem driver. Typically these aspects
+ // are essentially fixed for a given device, so this error would typically
+ // imply a configuration or plumbing problem.
+ //
+ // Sysmem should only call this once.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once
+ // * ZX_ERR_INVALID_ARGS - unexpected heap count or unexpected heap
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetPhysicalSecureHeaps SetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps, ::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:
+
+ // Gets the physical address and length of any secure heap whose physical
+ // range is configured via the TEE.
+ //
+ // Presently, these will be fixed physical addresses and lengths, with the
+ // location plumbed via the TEE.
+ //
+ // This is preferred over RegisterHeap() when there isn't any special
+ // heap-specific per-VMO setup or teardown required.
+ //
+ // The physical range must be secured/protected by the TEE before the
+ // securemem driver responds to this request with success.
+ //
+ // Sysmem should only call this once. Returning zero heaps is not a
+ // failure.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once.
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ static ::fidl::DecodeResult<GetPhysicalSecureHeapsResponse> GetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // This request from sysmem to the securemem driver lets the TEE know the
+ // physical memory address and length of any secure heap whose location is
+ // configured/established via sysmem.
+ //
+ // Only sysmem can call this because only sysmem is handed the client end
+ // of a FIDL channel serving this protocol, via RegisterSecureMem(). The
+ // securemem driver is the server end of this protocol.
+ //
+ // Presently, these physical ranges will be dynamically-allocated by sysmem
+ // early during boot.
+ //
+ // The heap ID is included in case that's relevant to the securemem driver,
+ // for more informative log messages, and for consistency with
+ // GetPhysicalSecureHeaps().
+ //
+ // The securemem driver must configure all the provided ranges as secure
+ // with the TEE before responding to this message with success.
+ //
+ // For heaps configured via sysmem, both the HeapType and heap location are
+ // configured via sysmem, and ZX_ERR_INVALID_ARGS will be the result if the
+ // securemem driver determines that the number of heaps or HeapType(s) are
+ // not what's supported by the securemem driver. Typically these aspects
+ // are essentially fixed for a given device, so this error would typically
+ // imply a configuration or plumbing problem.
+ //
+ // Sysmem should only call this once.
+ //
+ // Errors:
+ // * ZX_ERR_BAD_STATE - called more than once
+ // * ZX_ERR_INVALID_ARGS - unexpected heap count or unexpected heap
+ // * ZX_ERR_INTERNAL - generic internal error (such as in communication
+ // with TEE which doesn't generate zx_status_t errors).
+ // * other errors are possible, such as from communication failures or
+ // server propagation of zx_status_t failures
+ static ::fidl::DecodeResult<SetPhysicalSecureHeapsResponse> SetPhysicalSecureHeaps(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetPhysicalSecureHeapsRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = SecureMem;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetPhysicalSecureHeapsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Result result);
+ void ReplySuccess(::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps);
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer, ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps);
+ void Reply(::fidl::DecodedMessage<GetPhysicalSecureHeapsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetPhysicalSecureHeapsCompleter = ::fidl::Completer<GetPhysicalSecureHeapsCompleterBase>;
+
+ virtual void GetPhysicalSecureHeaps(GetPhysicalSecureHeapsCompleter::Sync _completer) = 0;
+
+ class SetPhysicalSecureHeapsCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Result result);
+ void ReplySuccess();
+ void ReplyError(int32_t error);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Result result);
+ void ReplySuccess(::fidl::BytePart _buffer);
+ void Reply(::fidl::DecodedMessage<SetPhysicalSecureHeapsResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SetPhysicalSecureHeapsCompleter = ::fidl::Completer<SetPhysicalSecureHeapsCompleterBase>;
+
+ virtual void SetPhysicalSecureHeaps(::llcpp::fuchsia::sysmem::PhysicalSecureHeaps heaps, SetPhysicalSecureHeapsCompleter::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 GetPhysicalSecureHeapsRequest(const ::fidl::DecodedMessage<SecureMem::GetPhysicalSecureHeapsRequest>& _msg);
+ static void GetPhysicalSecureHeapsResponse(const ::fidl::DecodedMessage<SecureMem::GetPhysicalSecureHeapsResponse>& _msg);
+ static void SetPhysicalSecureHeapsRequest(const ::fidl::DecodedMessage<SecureMem::SetPhysicalSecureHeapsRequest>& _msg);
+ static void SetPhysicalSecureHeapsResponse(const ::fidl::DecodedMessage<SecureMem::SetPhysicalSecureHeapsResponse>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferMemoryConstraintsTable;
+
+struct BufferMemoryConstraints {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferMemoryConstraintsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 280;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t min_size_bytes = {};
+
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t max_size_bytes = {};
+
+ bool physically_contiguous_required = {};
+
+ // If true, at least one participant requires secure memory.
+ //
+ // When aggregating BufferCollectionConstraints, these values boolean-OR.
+ bool secure_required = {};
+
+ // By default, participants must ensure the CPU can read or write data to
+ // the buffer without cache operations. If they support using the RAM
+ // domain, data must be available in RAM (with CPU cache state such that
+ // the RAM data won't get corrupted by a dirty CPU cache line writing
+ // incorrect data to RAM), and a consumer reading using the CPU must
+ // invalidate CPU cache before reading (the producer doesn't guarantee
+ // zero stale "clean" cache lines)
+ bool ram_domain_supported = {};
+
+ bool cpu_domain_supported = {};
+
+ bool inaccessible_domain_supported = {};
+
+ // Optional heap constraints. Participants that don't care which heap
+ // memory is allocated on should leave this field 0.
+ uint32_t heap_permitted_count = {};
+
+ ::fidl::Array<::llcpp::fuchsia::sysmem::HeapType, 32> heap_permitted = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_FormatModifierTable;
+
+struct FormatModifier {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_FormatModifierTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 8;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The upper 8 bits are a vendor code as allocated in FormatModifierVendor
+ // enum. The lower 56 bits are vendor-defined.
+ //
+ // This field and the values that go in this field are defined this way for
+ // compatibility reasons.
+ uint64_t value = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_PixelFormatTable;
+
+// Describes how the pixels within an image are represented.
+// Simple formats need only a type.
+// Parametric pixel formats may require additional properties.
+struct PixelFormat {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_PixelFormatTable;
+ 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;
+
+ ::llcpp::fuchsia::sysmem::PixelFormatType type = {};
+
+ // This bool effectively makes format_modifier optional, to satisfy
+ // 'Layout = "Simple"', to satisify "FIDL Simple C Bindings".
+ bool has_format_modifier = {};
+
+ ::llcpp::fuchsia::sysmem::FormatModifier format_modifier = {};
+};
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_VIVANTE = 432345564227567616u;
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_SAMSUNG = 288230376151711744u;
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_QCOM = 360287970189639680u;
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_NVIDIA = 216172782113783808u;
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_NONE = 0u;
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_INTEL = 72057594037927936u;
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_BROADCOM = 504403158265495552u;
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_ARM = 576460752303423488u;
+
+constexpr uint64_t FORMAT_MODIFIER_VENDOR_AMD = 144115188075855872u;
+
+constexpr uint64_t FORMAT_MODIFIER_VALUE_RESERVED = 72057594037927935u;
+
+constexpr uint64_t FORMAT_MODIFIER_INVALID = FORMAT_MODIFIER_VALUE_RESERVED;
+
+constexpr uint64_t FORMAT_MODIFIER_NONE = 0u;
+
+constexpr uint64_t FORMAT_MODIFIER_LINEAR = 0u;
+
+constexpr uint64_t FORMAT_MODIFIER_INTEL_I915_Y_TILED = 72057594037927938u;
+
+constexpr uint64_t FORMAT_MODIFIER_INTEL_I915_YF_TILED = 72057594037927939u;
+
+constexpr uint64_t FORMAT_MODIFIER_INTEL_I915_X_TILED = 72057594037927937u;
+
+constexpr uint64_t FORMAT_MODIFIER_ARM_AFBC_32x8 = 576460752303423490u;
+
+constexpr uint64_t FORMAT_MODIFIER_ARM_AFBC_16x16 = 576460752303423489u;
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_ColorSpaceTable;
+
+// Describes how the pixels within an image are meant to be presented.
+// Simple color spaces need only a type.
+// Parametric color spaces may require additional properties.
+struct ColorSpace {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_ColorSpaceTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 4;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::sysmem::ColorSpaceType type = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_ImageSpecTable;
+
+// Describes constraints for allocating images of some desired form.
+struct ImageSpec {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_ImageSpecTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 40;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Minimum width in pixels.
+ uint32_t min_width = {};
+
+ // Minimum height in pixels.
+ uint32_t min_height = {};
+
+ // Number of layers within a multi-layered image.
+ // Defaults to 1 if not specified.
+ uint32_t layers = {};
+
+ // Pixel format.
+ ::llcpp::fuchsia::sysmem::PixelFormat pixel_format = {};
+
+ // Color space.
+ ::llcpp::fuchsia::sysmem::ColorSpace color_space = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_ImageFormat_2Table;
+
+// Describes how an image is represented.
+struct ImageFormat_2 {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_ImageFormat_2Table;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 56;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Pixel format.
+ ::llcpp::fuchsia::sysmem::PixelFormat pixel_format = {};
+
+ // Row width in pixels that exist in the buffer. Must be >= display_width.
+ // Can be < the width implied by stride_bytes.
+ uint32_t coded_width = {};
+
+ // Number of rows. Must be >= display_height.
+ uint32_t coded_height = {};
+
+ uint32_t bytes_per_row = {};
+
+ // Row width in pixels that are to be displayed. This can be <=
+ // coded_width. Any cropping occurs on the right of the image (not left).
+ uint32_t display_width = {};
+
+ // Number of rows to be displayed. This can be <= coded_height, with any
+ // cropping on the bottom (not top).
+ uint32_t display_height = {};
+
+ // Number of layers within a multi-layered image.
+ uint32_t layers = {};
+
+ // Color space.
+ ::llcpp::fuchsia::sysmem::ColorSpace color_space = {};
+
+ // The pixel_aspect_ratio_width : pixel_aspect_ratio_height is the
+ // pixel aspect ratio (AKA sample aspect ratio aka SAR) for the luma
+ // (AKA Y) samples. A pixel_aspect_ratio of 1:1 mean square pixels. A
+ // pixel_aspect_ratio of 2:1 would mean pixels that are displayed twice
+ // as wide as they are tall. Codec implementation should ensure these
+ // two values are relatively prime by reducing the fraction (dividing
+ // both by GCF) if necessary.
+ //
+ // When has_pixel_aspect_ratio == false, pixel_aspect_ratio_width and
+ // pixel_aspect_ratio_height will both be 1, but in that case the
+ // pixel_aspect_ratio_width : pixel_aspect_ratio_height of 1:1 is just
+ // a very weak suggestion re. reasonable-ish handling, not in any way
+ // authoritative. In this case (or in any case really) the receiver of
+ // this message may have other OOB means to determine the actual
+ // pixel_aspect_ratio.
+ bool has_pixel_aspect_ratio = {};
+
+ uint32_t pixel_aspect_ratio_width = {};
+
+ uint32_t pixel_aspect_ratio_height = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_ImageFormatConstraintsTable;
+
+// Describes constraints on layout of image data in buffers.
+struct ImageFormatConstraints {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_ImageFormatConstraintsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 232;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The PixelFormat for which the following constraints apply. A
+ // participant may have more than one PixelFormat that's supported, in
+ // which case that participant can use a list of ImageFormatConstraints
+ // with an entry per PixelFormat. It's not uncommon for the other fields
+ // of ImageFormatConstraints to vary by PixelFormat - for example for a
+ // linear format to support smaller max size than a tiled format.
+ ::llcpp::fuchsia::sysmem::PixelFormat pixel_format = {};
+
+ // Empty is an error. Redundant entries are an error. Arbitrary ordering
+ // is not an error.
+ uint32_t color_spaces_count = {};
+
+ ::fidl::Array<::llcpp::fuchsia::sysmem::ColorSpace, 32> color_space = {};
+
+ // Minimum permitted width in pixels.
+ //
+ // For example a video decoder participant may set this field to the
+ // minimum coded_width that might potentially be specified by a stream. In
+ // contrast, required_min_coded_width would be set to the current
+ // coded_width specified by the stream. While min_coded_width aggregates
+ // by taking the max, required_min_coded_width aggregates by taking the
+ // min.
+ //
+ // See also required_min_coded_width.
+ uint32_t min_coded_width = {};
+
+ // Maximum width in pixels. For example Scenic may set this field
+ // (directly or via sub-participants) to the maximum width that can be
+ // composited.
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t max_coded_width = {};
+
+ // Minimum height in pixels. For example a video decoder participant may
+ // set this field to the coded_height specified by a stream.
+ uint32_t min_coded_height = {};
+
+ // Maximum height in pixels. For example Scenic may set this field
+ // (directly or via sub-participants) to the maximum height that can be
+ // composited.
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t max_coded_height = {};
+
+ // Must be >= the value implied by min_coded_width for plane 0.
+ uint32_t min_bytes_per_row = {};
+
+ // Must be >= the value implied by max_coded_width for plane 0.
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t max_bytes_per_row = {};
+
+ // The max image area in pixels is limited indirectly via
+ // BufferSettings.size_bytes, and can also be enforced directly via this
+ // field.
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t max_coded_width_times_coded_height = {};
+
+ // Number of layers within a multi-layered image.
+ // 0 is treated as 1.
+ uint32_t layers = {};
+
+ // coded_width % width_divisor must be 0.
+ // 0 is treated as 1.
+ uint32_t coded_width_divisor = {};
+
+ // coded_height % height_divisor must be 0.
+ // 0 is treated as 1.
+ uint32_t coded_height_divisor = {};
+
+ // bytes_per_row % bytes_per_row_divisor must be 0.
+ // 0 is treated as 1.
+ uint32_t bytes_per_row_divisor = {};
+
+ // vmo_usable_start % start_offset_divisor must be 0.
+ // 0 is treated as 1.
+ uint32_t start_offset_divisor = {};
+
+ // display_width % display_width_divisor must be 0.
+ // 0 is treated as 1.
+ uint32_t display_width_divisor = {};
+
+ // display_height % display_height_divisor must be 0.
+ // 0 is treated as 1.
+ uint32_t display_height_divisor = {};
+
+ // required_ dimension bounds.
+ //
+ // In contrast to the corresponding fields without "required_" at the
+ // start, these fields (when set to non-zero values) express a requirement
+ // that the resulting aggregated non-required_ fields specify a space that
+ // fully contain the space expressed by each participant's required_
+ // fields.
+ //
+ // For example, a producer video decoder is perfectly happy for the
+ // consumer to be willing to accept anything, and the video decoder doesn't
+ // really want to constrain the potential space of dimensions that might be
+ // seen in a stream and may be acceptable to the consumer, but the video
+ // decoder needs to ensure that the resulting dimension ranges contain
+ // at least the current dimensions decoded from the stream.
+ //
+ // Similarly, an initiator with a particular dynamic-dimension scenario in
+ // mind may wish to require up front that participants agree to handle at
+ // least the range of dimensions expected by the initiator in that
+ // scenario (else fail earlier rather than later, maybe trying again with
+ // smaller required_ space).
+ //
+ // It's much more common for a producer or initiator to set these fields
+ // than for a consumer to set these fields.
+ //
+ // While the non-required_ fields aggregate by taking the intersection, the
+ // required_ fields aggregate by taking the union.
+ //
+ // If set, the required_max_coded_width and required_max_coded_height will
+ // cause the allocated buffers to be large enough to hold an image that is
+ // required_max_coded_width * required_max_coded_height.
+ //
+ // TODO(dustingreen): Make it easier to allocate buffers of minimal size
+ // that can (optionally) also handle 90 degree rotated version of the max
+ // dimensions / alternate required bounds for another main aspect ratio.
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t required_min_coded_width = {};
+
+ uint32_t required_max_coded_width = {};
+
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t required_min_coded_height = {};
+
+ uint32_t required_max_coded_height = {};
+
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t required_min_bytes_per_row = {};
+
+ uint32_t required_max_bytes_per_row = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_ImageFormatTable;
+
+// Describes how an image is represented.
+struct ImageFormat {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_ImageFormatTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 72;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Row width in pixels.
+ uint32_t width = {};
+
+ // Number of rows.
+ uint32_t height = {};
+
+ // Number of layers within a multi-layered image.
+ // Defaults to 1 if not specified.
+ uint32_t layers = {};
+
+ // Pixel format.
+ ::llcpp::fuchsia::sysmem::PixelFormat pixel_format = {};
+
+ // Color space.
+ ::llcpp::fuchsia::sysmem::ColorSpace color_space = {};
+
+ ::fidl::Array<::llcpp::fuchsia::sysmem::ImagePlane, 4> planes = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferFormatTable;
+
+// Describes how the contents of buffers are represented.
+// Buffers of each type are described by their own tables.
+struct BufferFormat {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferFormatTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 80;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // Since this struct used to be a single member union, we kept the tag
+ // to avoid any wire format changes. The tag must be set to `0`,
+ // no other value is correct.
+ uint32_t tag = {};
+
+ ::llcpp::fuchsia::sysmem::ImageFormat image = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionInfoTable;
+
+// Information about a buffer collection and its buffers.
+struct BufferCollectionInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionInfoTable;
+ static constexpr uint32_t MaxNumHandles = 64;
+ static constexpr uint32_t PrimarySize = 352;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The number of buffers in the collection.
+ uint32_t buffer_count = {};
+
+ // Describes how the contents of buffers are represented.
+ // All buffers within the collection have the same format.
+ ::llcpp::fuchsia::sysmem::BufferFormat format = {};
+
+ // VMO handles for each buffer in the collection.
+ // The VMOs are only present when the buffers are backed by VMOs.
+ //
+ // If present, all the VMOs after `buffer_count` are invalid handles.
+ // All buffer VMO handles have identical size and access rights.
+ // The VMO access rights are determined based on the usages which the
+ // client specified when allocating the buffer collection. For example,
+ // a client which expressed a read-only usage will receive VMOs without
+ // write rights.
+ ::fidl::Array<::zx::vmo, 64> vmos = {};
+
+ // The size of each VMO provided.
+ // This property is only present when the buffers are backed by VMOs.
+ uint64_t vmo_size = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferMemorySettingsTable;
+
+struct BufferMemorySettings {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferMemorySettingsTable;
+ 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;
+
+ uint32_t size_bytes = {};
+
+ bool is_physically_contiguous = {};
+
+ bool is_secure = {};
+
+ ::llcpp::fuchsia::sysmem::CoherencyDomain coherency_domain = {};
+
+ // The specific heap from which buffers are allocated.
+ // See above in this file for heap identifier values.
+ ::llcpp::fuchsia::sysmem::HeapType heap = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SingleBufferSettingsTable;
+
+// After the initial buffer allocation, it's allowed to close old buffers and
+// allocate new buffers. When a new buffer is allocated its settings can differ
+// from the rest of the buffers in the collection, and the single buffer's
+// settings are delivered via OnSingleBufferAllocated() using this struct:
+struct SingleBufferSettings {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SingleBufferSettingsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 264;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::sysmem::BufferMemorySettings buffer_settings = {};
+
+ // Buffers holding data that is not uncompressed image data will not have
+ // this field set. Buffers holding data that is uncompressed image data
+ // _may_ have this field set.
+ //
+ // At least for now, changing the PixelFormat requires re-allocating
+ // buffers.
+ bool has_image_format_constraints = {};
+
+ ::llcpp::fuchsia::sysmem::ImageFormatConstraints image_format_constraints = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_SingleBufferInfoTable;
+
+struct SingleBufferInfo {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_SingleBufferInfoTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 280;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ ::llcpp::fuchsia::sysmem::SingleBufferSettings settings = {};
+
+ ::llcpp::fuchsia::sysmem::VmoBuffer buffer = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionInfo_2Table;
+
+// Information about a buffer collection and its buffers.
+struct BufferCollectionInfo_2 {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionInfo_2Table;
+ static constexpr uint32_t MaxNumHandles = 64;
+ static constexpr uint32_t PrimarySize = 1296;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // If this is the initial buffer collection allocation, this is the total
+ // number of buffers. If this is a single buffer allocation, this is zero,
+ // and the rest of the fields only apply to the single buffer.
+ uint32_t buffer_count = {};
+
+ // These settings apply to all the buffers in the inital buffer allocation.
+ ::llcpp::fuchsia::sysmem::SingleBufferSettings settings = {};
+
+ // VMO handles (and vmo_usable_start offset) for each buffer in the
+ // collection.
+ //
+ // If present, all the VMOs at or after index `buffer_count` are invalid (0)
+ // handles.
+ //
+ // All buffer VMO handles have identical size and access rights. The size
+ // is in settings.buffer_settings.size_bytes.
+ //
+ // The VMO access rights are determined based on the usages which the
+ // client specified when allocating the buffer collection. For example,
+ // a client which expressed a read-only usage will receive VMOs without
+ // write rights. In addition, the rights can be attenuated by the parameter
+ // to BufferCollectionToken.Duplicate() calls.
+ ::fidl::Array<::llcpp::fuchsia::sysmem::VmoBuffer, 64> buffers = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnDuplicatedTokensKnownByServerRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnDuplicatedTokensKnownByServerResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnBuffersAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnBuffersAllocatedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnAllocateSingleBufferDoneRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionEventsOnAllocateSingleBufferDoneResponseTable;
+
+// This interface intentionally doesn't include any event for
+// OnOldBufferClosed(), because such an event could arrive at a participant too
+// soon to be useful. Instead, such an indication should be made in-band within
+// FIDL interfaces that deliver packets to downstream participants.
+class BufferCollectionEvents final {
+ BufferCollectionEvents() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.sysmem.BufferCollectionEvents";
+
+ using OnDuplicatedTokensKnownByServerRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OnBuffersAllocatedRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionEventsOnBuffersAllocatedRequestTable;
+ static constexpr uint32_t MaxNumHandles = 64;
+ static constexpr uint32_t PrimarySize = 1320;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 1320;
+ 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;
+ };
+
+ struct OnAllocateSingleBufferDoneRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionEventsOnAllocateSingleBufferDoneRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 304;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 304;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class OnDuplicatedTokensKnownByServer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OnDuplicatedTokensKnownByServer_Impl(::zx::unowned_channel _client_end);
+ ~OnDuplicatedTokensKnownByServer_Impl() = default;
+ OnDuplicatedTokensKnownByServer_Impl(OnDuplicatedTokensKnownByServer_Impl&& other) = default;
+ OnDuplicatedTokensKnownByServer_Impl& operator=(OnDuplicatedTokensKnownByServer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class OnBuffersAllocated_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OnBuffersAllocated_Impl(::zx::unowned_channel _client_end, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info);
+ ~OnBuffersAllocated_Impl() = default;
+ OnBuffersAllocated_Impl(OnBuffersAllocated_Impl&& other) = default;
+ OnBuffersAllocated_Impl& operator=(OnBuffersAllocated_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class OnAllocateSingleBufferDone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OnAllocateSingleBufferDone_Impl(::zx::unowned_channel _client_end, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info);
+ ~OnAllocateSingleBufferDone_Impl() = default;
+ OnAllocateSingleBufferDone_Impl(OnAllocateSingleBufferDone_Impl&& other) = default;
+ OnAllocateSingleBufferDone_Impl& operator=(OnAllocateSingleBufferDone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using OnDuplicatedTokensKnownByServer = OnDuplicatedTokensKnownByServer_Impl;
+ using OnBuffersAllocated = OnBuffersAllocated_Impl;
+ using OnAllocateSingleBufferDone = OnAllocateSingleBufferDone_Impl;
+ };
+
+ // 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:
+ class OnDuplicatedTokensKnownByServer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OnDuplicatedTokensKnownByServer_Impl(::zx::unowned_channel _client_end);
+ ~OnDuplicatedTokensKnownByServer_Impl() = default;
+ OnDuplicatedTokensKnownByServer_Impl(OnDuplicatedTokensKnownByServer_Impl&& other) = default;
+ OnDuplicatedTokensKnownByServer_Impl& operator=(OnDuplicatedTokensKnownByServer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class OnBuffersAllocated_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OnBuffersAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info);
+ ~OnBuffersAllocated_Impl() = default;
+ OnBuffersAllocated_Impl(OnBuffersAllocated_Impl&& other) = default;
+ OnBuffersAllocated_Impl& operator=(OnBuffersAllocated_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class OnAllocateSingleBufferDone_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OnAllocateSingleBufferDone_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info);
+ ~OnAllocateSingleBufferDone_Impl() = default;
+ OnAllocateSingleBufferDone_Impl(OnAllocateSingleBufferDone_Impl&& other) = default;
+ OnAllocateSingleBufferDone_Impl& operator=(OnAllocateSingleBufferDone_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using OnDuplicatedTokensKnownByServer = OnDuplicatedTokensKnownByServer_Impl;
+ using OnBuffersAllocated = OnBuffersAllocated_Impl;
+ using OnAllocateSingleBufferDone = OnAllocateSingleBufferDone_Impl;
+ };
+
+ 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_; }
+
+ // See comments on BufferCollectionToken::Sync().
+ //
+ // This message only indicates that the server has reached the point where
+ // it knows about previously created tokens Duplicate()ed from the token
+ // used to create this BufferCollection.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::OnDuplicatedTokensKnownByServer OnDuplicatedTokensKnownByServer();
+
+
+ // This event inidicates that buffer allocation is over, whether succesful
+ // or failed.
+ //
+ // This event will eventually be sent by the server (unless the
+ // BufferCollection channel closes first).
+ //
+ // `status`:
+ // `ZX_OK` if successful.
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` The buffer information, including VMO handles.
+ // If `status` is not `ZX_OK`, `buffer_collection_info` is default
+ // initialized and contains no meaningful information.
+ // Request is heap-allocated.
+ ResultOf::OnBuffersAllocated OnBuffersAllocated(int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info);
+
+ // This event inidicates that buffer allocation is over, whether succesful
+ // or failed.
+ //
+ // This event will eventually be sent by the server (unless the
+ // BufferCollection channel closes first).
+ //
+ // `status`:
+ // `ZX_OK` if successful.
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` The buffer information, including VMO handles.
+ // If `status` is not `ZX_OK`, `buffer_collection_info` is default
+ // initialized and contains no meaningful information.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OnBuffersAllocated OnBuffersAllocated(::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info);
+
+ // A participant can learn when a new buffer is allocated via this event.
+ // The only participant that will see a failing status is the participant
+ // that attempted the single buffer allocation. Other participants will
+ // only see successful single buffer allocations.
+ //
+ // `status`:
+ //
+ // `ZX_OK` if successful. This can be seen by any participant (whether
+ // sender of AllocateSingleBuffer() or not.)
+ //
+ // `ZX_ERR_NOT_FOUND` if the buffer_index sent via
+ // CheckSingleBufferAllocated() isn't known to the server. This can be seen
+ // by any participant (whether sender of AllocateSingleBuffer() or not.)
+ //
+ // These error codes are only ever seen by the sender of
+ // AllocateSingleBuffer():
+ //
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ // Allocates 304 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::OnAllocateSingleBufferDone OnAllocateSingleBufferDone(int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info);
+
+ // A participant can learn when a new buffer is allocated via this event.
+ // The only participant that will see a failing status is the participant
+ // that attempted the single buffer allocation. Other participants will
+ // only see successful single buffer allocations.
+ //
+ // `status`:
+ //
+ // `ZX_OK` if successful. This can be seen by any participant (whether
+ // sender of AllocateSingleBuffer() or not.)
+ //
+ // `ZX_ERR_NOT_FOUND` if the buffer_index sent via
+ // CheckSingleBufferAllocated() isn't known to the server. This can be seen
+ // by any participant (whether sender of AllocateSingleBuffer() or not.)
+ //
+ // These error codes are only ever seen by the sender of
+ // AllocateSingleBuffer():
+ //
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OnAllocateSingleBufferDone OnAllocateSingleBufferDone(::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info);
+
+ 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:
+
+ // See comments on BufferCollectionToken::Sync().
+ //
+ // This message only indicates that the server has reached the point where
+ // it knows about previously created tokens Duplicate()ed from the token
+ // used to create this BufferCollection.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::OnDuplicatedTokensKnownByServer OnDuplicatedTokensKnownByServer(::zx::unowned_channel _client_end);
+
+
+ // This event inidicates that buffer allocation is over, whether succesful
+ // or failed.
+ //
+ // This event will eventually be sent by the server (unless the
+ // BufferCollection channel closes first).
+ //
+ // `status`:
+ // `ZX_OK` if successful.
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` The buffer information, including VMO handles.
+ // If `status` is not `ZX_OK`, `buffer_collection_info` is default
+ // initialized and contains no meaningful information.
+ // Request is heap-allocated.
+ static ResultOf::OnBuffersAllocated OnBuffersAllocated(::zx::unowned_channel _client_end, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info);
+
+ // This event inidicates that buffer allocation is over, whether succesful
+ // or failed.
+ //
+ // This event will eventually be sent by the server (unless the
+ // BufferCollection channel closes first).
+ //
+ // `status`:
+ // `ZX_OK` if successful.
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` The buffer information, including VMO handles.
+ // If `status` is not `ZX_OK`, `buffer_collection_info` is default
+ // initialized and contains no meaningful information.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OnBuffersAllocated OnBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info);
+
+ // A participant can learn when a new buffer is allocated via this event.
+ // The only participant that will see a failing status is the participant
+ // that attempted the single buffer allocation. Other participants will
+ // only see successful single buffer allocations.
+ //
+ // `status`:
+ //
+ // `ZX_OK` if successful. This can be seen by any participant (whether
+ // sender of AllocateSingleBuffer() or not.)
+ //
+ // `ZX_ERR_NOT_FOUND` if the buffer_index sent via
+ // CheckSingleBufferAllocated() isn't known to the server. This can be seen
+ // by any participant (whether sender of AllocateSingleBuffer() or not.)
+ //
+ // These error codes are only ever seen by the sender of
+ // AllocateSingleBuffer():
+ //
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ // Allocates 304 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::OnAllocateSingleBufferDone OnAllocateSingleBufferDone(::zx::unowned_channel _client_end, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info);
+
+ // A participant can learn when a new buffer is allocated via this event.
+ // The only participant that will see a failing status is the participant
+ // that attempted the single buffer allocation. Other participants will
+ // only see successful single buffer allocations.
+ //
+ // `status`:
+ //
+ // `ZX_OK` if successful. This can be seen by any participant (whether
+ // sender of AllocateSingleBuffer() or not.)
+ //
+ // `ZX_ERR_NOT_FOUND` if the buffer_index sent via
+ // CheckSingleBufferAllocated() isn't known to the server. This can be seen
+ // by any participant (whether sender of AllocateSingleBuffer() or not.)
+ //
+ // These error codes are only ever seen by the sender of
+ // AllocateSingleBuffer():
+ //
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OnAllocateSingleBufferDone OnAllocateSingleBufferDone(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info);
+
+ };
+
+ // 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:
+
+ // See comments on BufferCollectionToken::Sync().
+ //
+ // This message only indicates that the server has reached the point where
+ // it knows about previously created tokens Duplicate()ed from the token
+ // used to create this BufferCollection.
+ static ::fidl::internal::StatusAndError OnDuplicatedTokensKnownByServer(::zx::unowned_channel _client_end);
+
+ // This event inidicates that buffer allocation is over, whether succesful
+ // or failed.
+ //
+ // This event will eventually be sent by the server (unless the
+ // BufferCollection channel closes first).
+ //
+ // `status`:
+ // `ZX_OK` if successful.
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` The buffer information, including VMO handles.
+ // If `status` is not `ZX_OK`, `buffer_collection_info` is default
+ // initialized and contains no meaningful information.
+ static ::fidl::internal::StatusAndError OnBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnBuffersAllocatedRequest> params);
+
+ // A participant can learn when a new buffer is allocated via this event.
+ // The only participant that will see a failing status is the participant
+ // that attempted the single buffer allocation. Other participants will
+ // only see successful single buffer allocations.
+ //
+ // `status`:
+ //
+ // `ZX_OK` if successful. This can be seen by any participant (whether
+ // sender of AllocateSingleBuffer() or not.)
+ //
+ // `ZX_ERR_NOT_FOUND` if the buffer_index sent via
+ // CheckSingleBufferAllocated() isn't known to the server. This can be seen
+ // by any participant (whether sender of AllocateSingleBuffer() or not.)
+ //
+ // These error codes are only ever seen by the sender of
+ // AllocateSingleBuffer():
+ //
+ // `ZX_ERR_NO_MEMORY` if the request is valid but cannot be fulfilled due to
+ // resource exhaustion.
+ // `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to obtain the
+ // buffers it requested.
+ // `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be satisfied,
+ // perhaps due to hardware limitations.
+ static ::fidl::internal::StatusAndError OnAllocateSingleBufferDone(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OnAllocateSingleBufferDoneRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = BufferCollectionEvents;
+ using _Base = ::fidl::CompleterBase;
+
+ using OnDuplicatedTokensKnownByServerCompleter = ::fidl::Completer<>;
+
+ virtual void OnDuplicatedTokensKnownByServer(OnDuplicatedTokensKnownByServerCompleter::Sync _completer) = 0;
+
+ using OnBuffersAllocatedCompleter = ::fidl::Completer<>;
+
+ virtual void OnBuffersAllocated(int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info, OnBuffersAllocatedCompleter::Sync _completer) = 0;
+
+ using OnAllocateSingleBufferDoneCompleter = ::fidl::Completer<>;
+
+ virtual void OnAllocateSingleBufferDone(int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info, OnAllocateSingleBufferDoneCompleter::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 OnDuplicatedTokensKnownByServerRequest(const ::fidl::DecodedMessage<BufferCollectionEvents::OnDuplicatedTokensKnownByServerRequest>& _msg);
+ static void OnBuffersAllocatedRequest(const ::fidl::DecodedMessage<BufferCollectionEvents::OnBuffersAllocatedRequest>& _msg);
+ static void OnAllocateSingleBufferDoneRequest(const ::fidl::DecodedMessage<BufferCollectionEvents::OnAllocateSingleBufferDoneRequest>& _msg);
+ };
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferUsageTable;
+
+struct BufferUsage {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferUsageTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 20;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint32_t none = {};
+
+ uint32_t cpu = {};
+
+ uint32_t vulkan = {};
+
+ uint32_t display = {};
+
+ uint32_t video = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionConstraintsTable;
+
+// Constraints on BufferCollection parameters. These constraints can be
+// specified per-participant. The sysmem service implements aggregation of
+// constraints from multiple participants.
+struct BufferCollectionConstraints {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionConstraintsTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 7760;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ // The usage is only meant as a hint to help sysmem choose a more optimal
+ // PixelFormat or similar when multiple compatible options exist.
+ //
+ // When aggregating BufferCollectionConstraints, these values bitwise-OR.
+ //
+ // At least one usage bit must be specified unless the whole
+ // BufferCollectionConstraints is logically null due to !has_constraints.
+ ::llcpp::fuchsia::sysmem::BufferUsage usage = {};
+
+ // Per-participant minimum number of buffers that are needed for camping
+ // purposes. A participant should specify a number for min_buffer_count
+ // that's >= the maximum number of buffers that the participant may
+ // concurrently camp on for any non-transient period of time.
+ //
+ // For example, a video decoder would specify (at least) the maximum number
+ // of reference frames + 1 frame currently being decoded into.
+ //
+ // A participant must not camp on more buffers than specified here (except
+ // very transiently) else processing may get stuck.
+ //
+ // When aggregating BufferCollectionConstraints, these values add.
+ //
+ // In testing scenarios, camping on more buffers than this for any
+ // significant duration may (ideally will) be flagged as a failure. In
+ // testing scenarios, the participant may not be provided with more buffers
+ // than this concurrently.
+ uint32_t min_buffer_count_for_camping = {};
+
+ // Per-participant minimum number of buffers that are needed for slack
+ // reasons, for better overlap of processing / better performance.
+ //
+ // When aggregating BufferCollectionConstraints, these values add.
+ //
+ // A participant should typically specify 0 or 1 here - typically 0 is
+ // appropriate if min_buffer_count_for_camping is already enough to keep
+ // the participant busy 100% of the time when the participant is slightly
+ // behind, while 1 can be appropriate if 1 more buffer than strictly needed
+ // for min-camping reasons gives enough slack to stay busy 100% of the time
+ // (when slightly behind, vs. lower % without the extra buffer).
+ //
+ // In testing scenarios, this field may be forced to 0, and all
+ // participants are expected to continue to work without getting stuck. If
+ // a buffer is needed for forward progress reasons, that buffer should be
+ // accounted for in min_buffer_count_for_camping.
+ uint32_t min_buffer_count_for_dedicated_slack = {};
+
+ // Similar to min_buffer_count_for_dedicated_slack, except when aggregating
+ // these values max (instead of add). The value here is not shared with
+ // any participant's min_buffer_count_for_dedicated_slack.
+ //
+ // A participant can specify > 0 here if a participant would like to ensure
+ // there's some slack overall, but doesn't need that slack to be dedicated.
+ //
+ // The choice whether to use min_buffer_count_for_dedicated_slack or
+ // min_buffer_count_for_shared_slack (or both) will typically be about the
+ // degree to which the extra slack improves performance.
+ //
+ // In testing scenarios, this field may be forced to 0, and all
+ // participants are expected to continue to work without getting stuck. If
+ // a buffer is needed for forward progress reasons, that buffer should be
+ // accounted for in min_buffer_count_for_camping.
+ uint32_t min_buffer_count_for_shared_slack = {};
+
+ // A particularly-picky participant may unfortunately need to demand a tight
+ // range of buffer_count, or even a specific buffer_count. This field
+ // should remain 0 unless a participant really must set this field to
+ // constrain the overall BufferCollectionInfo_2.buffer_count. Any such
+ // participant should still fill out the min_buffer_count_for_* fields
+ // above.
+ uint32_t min_buffer_count = {};
+
+ // 0 is treated as 0xFFFFFFFF.
+ uint32_t max_buffer_count = {};
+
+ // Constraints on BufferCollectionSettings.buffer_settings.
+ //
+ // A participant that intends to specify image_format_constraints_count > 1
+ // will typically specify the minimum buffer size implicitly via
+ // image_format_constraints, and possibly specify only the max buffer size
+ // via buffer_memory_constraints.
+ bool has_buffer_memory_constraints = {};
+
+ ::llcpp::fuchsia::sysmem::BufferMemoryConstraints buffer_memory_constraints = {};
+
+ // Optional constraints on the image format parameters of an image stored
+ // in a buffer of the BufferCollection. This includes pixel format and
+ // image layout. These constraints are per-pixel-format, so more than one
+ // is permitted.
+ //
+ // When aggregating, only pixel formats that are specified by all
+ // particpants with non-zero image_format_constraints_count (and non-Null)
+ // BufferCollectionConstraints) are retained.
+ uint32_t image_format_constraints_count = {};
+
+ ::fidl::Array<::llcpp::fuchsia::sysmem::ImageFormatConstraints, 32> image_format_constraints = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSetEventSinkRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSetEventSinkResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSyncRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSyncResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSetConstraintsRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionSetConstraintsResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionWaitForBuffersAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionWaitForBuffersAllocatedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCheckBuffersAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCheckBuffersAllocatedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCloseSingleBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCloseSingleBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionAllocateSingleBufferRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionAllocateSingleBufferResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionWaitForSingleBufferAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionWaitForSingleBufferAllocatedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCheckSingleBufferAllocatedRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCheckSingleBufferAllocatedResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCloseRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_sysmem_BufferCollectionCloseResponseTable;
+
+// BufferCollection is a connection directly from a participant to sysmem re.
+// a logical BufferCollection; typically the logical BufferCollection is shared
+// with other participants. In other words, an instance of the BufferCollection
+// interface is a view of a "LogicalBufferCollection".
+//
+// This connection exists to facilitate async indication of when the logical
+// BufferCollection has been populated with buffers.
+//
+// Also, the channel's closure by the server is an indication to the client
+// that the client should close all VMO handles that were obtained from the
+// BufferCollection ASAP.
+//
+// Also, this interface may in future allow specifying constraints in other
+// ways, and may allow for back-and-forth negotiation of constraints to some
+// degree.
+//
+// This interface may in future allow for more than 64 VMO handles per
+// BufferCollection, but currently the limit is 64.
+//
+// This interface may in future allow for allocating/deallocating single
+// buffers.
+//
+// Some initiators may wait a short duration until all old logical
+// BufferCollection VMO handles have closed (or until the short duration times
+// out) before allocating a new BufferCollection, to help control physical
+// memory fragmentation and avoid overlap of buffer allocation lifetimes for
+// the old and new collections. Collections can be large enough that it's worth
+// avoiding allocation overlap (in time).
+class BufferCollection final {
+ BufferCollection() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.sysmem.BufferCollection";
+
+ struct SetEventSinkRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel events;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionSetEventSinkRequestTable;
+ 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 SyncResponse = ::fidl::AnyZeroArgMessage;
+ using SyncRequest = ::fidl::AnyZeroArgMessage;
+
+ struct SetConstraintsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ bool has_constraints;
+ ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionSetConstraintsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 7784;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 7784;
+ 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;
+ };
+
+ struct WaitForBuffersAllocatedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionWaitForBuffersAllocatedResponseTable;
+ static constexpr uint32_t MaxNumHandles = 64;
+ static constexpr uint32_t PrimarySize = 1320;
+ 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 WaitForBuffersAllocatedRequest = ::fidl::AnyZeroArgMessage;
+
+ struct CheckBuffersAllocatedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionCheckBuffersAllocatedResponseTable;
+ 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 CheckBuffersAllocatedRequest = ::fidl::AnyZeroArgMessage;
+
+ struct CloseSingleBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t buffer_index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionCloseSingleBufferRequestTable;
+ 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;
+ };
+
+ struct AllocateSingleBufferRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t buffer_index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionAllocateSingleBufferRequestTable;
+ 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;
+ };
+
+ struct WaitForSingleBufferAllocatedResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionWaitForSingleBufferAllocatedResponseTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 304;
+ 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 WaitForSingleBufferAllocatedRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t buffer_index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionWaitForSingleBufferAllocatedRequestTable;
+ 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 = WaitForSingleBufferAllocatedResponse;
+ };
+
+ struct CheckSingleBufferAllocatedRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint64_t buffer_index;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_sysmem_BufferCollectionCheckSingleBufferAllocatedRequestTable;
+ 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 CloseRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class SetEventSink_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetEventSink_Impl(::zx::unowned_channel _client_end, ::zx::channel events);
+ ~SetEventSink_Impl() = default;
+ SetEventSink_Impl(SetEventSink_Impl&& other) = default;
+ SetEventSink_Impl& operator=(SetEventSink_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Sync_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class SetConstraints_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetConstraints_Impl(::zx::unowned_channel _client_end, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints);
+ ~SetConstraints_Impl() = default;
+ SetConstraints_Impl(SetConstraints_Impl&& other) = default;
+ SetConstraints_Impl& operator=(SetConstraints_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class WaitForBuffersAllocated_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WaitForBuffersAllocated_Impl(::zx::unowned_channel _client_end);
+ ~WaitForBuffersAllocated_Impl() = default;
+ WaitForBuffersAllocated_Impl(WaitForBuffersAllocated_Impl&& other) = default;
+ WaitForBuffersAllocated_Impl& operator=(WaitForBuffersAllocated_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 CheckBuffersAllocated_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CheckBuffersAllocated_Impl(::zx::unowned_channel _client_end);
+ ~CheckBuffersAllocated_Impl() = default;
+ CheckBuffersAllocated_Impl(CheckBuffersAllocated_Impl&& other) = default;
+ CheckBuffersAllocated_Impl& operator=(CheckBuffersAllocated_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class CloseSingleBuffer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CloseSingleBuffer_Impl(::zx::unowned_channel _client_end, uint64_t buffer_index);
+ ~CloseSingleBuffer_Impl() = default;
+ CloseSingleBuffer_Impl(CloseSingleBuffer_Impl&& other) = default;
+ CloseSingleBuffer_Impl& operator=(CloseSingleBuffer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AllocateSingleBuffer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AllocateSingleBuffer_Impl(::zx::unowned_channel _client_end, uint64_t buffer_index);
+ ~AllocateSingleBuffer_Impl() = default;
+ AllocateSingleBuffer_Impl(AllocateSingleBuffer_Impl&& other) = default;
+ AllocateSingleBuffer_Impl& operator=(AllocateSingleBuffer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class WaitForSingleBufferAllocated_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ WaitForSingleBufferAllocated_Impl(::zx::unowned_channel _client_end, uint64_t buffer_index);
+ ~WaitForSingleBufferAllocated_Impl() = default;
+ WaitForSingleBufferAllocated_Impl(WaitForSingleBufferAllocated_Impl&& other) = default;
+ WaitForSingleBufferAllocated_Impl& operator=(WaitForSingleBufferAllocated_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class CheckSingleBufferAllocated_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CheckSingleBufferAllocated_Impl(::zx::unowned_channel _client_end, uint64_t buffer_index);
+ ~CheckSingleBufferAllocated_Impl() = default;
+ CheckSingleBufferAllocated_Impl(CheckSingleBufferAllocated_Impl&& other) = default;
+ CheckSingleBufferAllocated_Impl& operator=(CheckSingleBufferAllocated_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using SetEventSink = SetEventSink_Impl;
+ using Sync = Sync_Impl<SyncResponse>;
+ using SetConstraints = SetConstraints_Impl;
+ using WaitForBuffersAllocated = WaitForBuffersAllocated_Impl<WaitForBuffersAllocatedResponse>;
+ using CheckBuffersAllocated = CheckBuffersAllocated_Impl<CheckBuffersAllocatedResponse>;
+ using CloseSingleBuffer = CloseSingleBuffer_Impl;
+ using AllocateSingleBuffer = AllocateSingleBuffer_Impl;
+ using WaitForSingleBufferAllocated = WaitForSingleBufferAllocated_Impl<WaitForSingleBufferAllocatedResponse>;
+ using CheckSingleBufferAllocated = CheckSingleBufferAllocated_Impl;
+ using Close = Close_Impl;
+ };
+
+ // 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:
+ class SetEventSink_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetEventSink_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel events);
+ ~SetEventSink_Impl() = default;
+ SetEventSink_Impl(SetEventSink_Impl&& other) = default;
+ SetEventSink_Impl& operator=(SetEventSink_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class Sync_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Sync_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Sync_Impl() = default;
+ Sync_Impl(Sync_Impl&& other) = default;
+ Sync_Impl& operator=(Sync_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class SetConstraints_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ SetConstraints_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints);
+ ~SetConstraints_Impl() = default;
+ SetConstraints_Impl(SetConstraints_Impl&& other) = default;
+ SetConstraints_Impl& operator=(SetConstraints_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class WaitForBuffersAllocated_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WaitForBuffersAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~WaitForBuffersAllocated_Impl() = default;
+ WaitForBuffersAllocated_Impl(WaitForBuffersAllocated_Impl&& other) = default;
+ WaitForBuffersAllocated_Impl& operator=(WaitForBuffersAllocated_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 CheckBuffersAllocated_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CheckBuffersAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~CheckBuffersAllocated_Impl() = default;
+ CheckBuffersAllocated_Impl(CheckBuffersAllocated_Impl&& other) = default;
+ CheckBuffersAllocated_Impl& operator=(CheckBuffersAllocated_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class CloseSingleBuffer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CloseSingleBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index);
+ ~CloseSingleBuffer_Impl() = default;
+ CloseSingleBuffer_Impl(CloseSingleBuffer_Impl&& other) = default;
+ CloseSingleBuffer_Impl& operator=(CloseSingleBuffer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class AllocateSingleBuffer_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ AllocateSingleBuffer_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index);
+ ~AllocateSingleBuffer_Impl() = default;
+ AllocateSingleBuffer_Impl(AllocateSingleBuffer_Impl&& other) = default;
+ AllocateSingleBuffer_Impl& operator=(AllocateSingleBuffer_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class WaitForSingleBufferAllocated_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ WaitForSingleBufferAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index, ::fidl::BytePart _response_buffer);
+ ~WaitForSingleBufferAllocated_Impl() = default;
+ WaitForSingleBufferAllocated_Impl(WaitForSingleBufferAllocated_Impl&& other) = default;
+ WaitForSingleBufferAllocated_Impl& operator=(WaitForSingleBufferAllocated_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class CheckSingleBufferAllocated_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ CheckSingleBufferAllocated_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index);
+ ~CheckSingleBufferAllocated_Impl() = default;
+ CheckSingleBufferAllocated_Impl(CheckSingleBufferAllocated_Impl&& other) = default;
+ CheckSingleBufferAllocated_Impl& operator=(CheckSingleBufferAllocated_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class Close_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using SetEventSink = SetEventSink_Impl;
+ using Sync = Sync_Impl<SyncResponse>;
+ using SetConstraints = SetConstraints_Impl;
+ using WaitForBuffersAllocated = WaitForBuffersAllocated_Impl<WaitForBuffersAllocatedResponse>;
+ using CheckBuffersAllocated = CheckBuffersAllocated_Impl<CheckBuffersAllocatedResponse>;
+ using CloseSingleBuffer = CloseSingleBuffer_Impl;
+ using AllocateSingleBuffer = AllocateSingleBuffer_Impl;
+ using WaitForSingleBufferAllocated = WaitForSingleBufferAllocated_Impl<WaitForSingleBufferAllocatedResponse>;
+ using CheckSingleBufferAllocated = CheckSingleBufferAllocated_Impl;
+ using Close = Close_Impl;
+ };
+
+ 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_; }
+
+ // At least for now, the only way to get events from a BufferCollection is
+ // to set a reverse BufferCollectionEvents channel. This can be sent up to
+ // once at any point during BufferCollection channel lifetime. All events
+ // are one-shot events, and will be sent immediately via `events` if the
+ // one-shot event's condition has already become true (once true will stay
+ // true; only goes from false to true once).
+ //
+ // `events` is the client end of a BufferCollectionEvents which will be sent
+ // one-way messages indicating events relevant to this BufferCollection
+ // channel (some may be specific to this BufferCollection channel and some
+ // may be relevant to the overall logical BufferCollection).
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::SetEventSink SetEventSink(::zx::channel events);
+
+ // At least for now, the only way to get events from a BufferCollection is
+ // to set a reverse BufferCollectionEvents channel. This can be sent up to
+ // once at any point during BufferCollection channel lifetime. All events
+ // are one-shot events, and will be sent immediately via `events` if the
+ // one-shot event's condition has already become true (once true will stay
+ // true; only goes from false to true once).
+ //
+ // `events` is the client end of a BufferCollectionEvents which will be sent
+ // one-way messages indicating events relevant to this BufferCollection
+ // channel (some may be specific to this BufferCollection channel and some
+ // may be relevant to the overall logical BufferCollection).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetEventSink SetEventSink(::fidl::BytePart _request_buffer, ::zx::channel events);
+
+ // See comments on BufferCollectionToken::Sync().
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Sync Sync();
+
+
+ // Provide BufferCollectionConstraints to the logical BufferCollection.
+ //
+ // Participants with read but not write can only call SetConstraints() once.
+ //
+ // Participants with write can call SetConstraints() more than once. The
+ // initial buffer allocation will use the constraints in the first call to
+ // SetConstraints(). Among other things, this allows a decoder to attempt
+ // to allocate a new buffer that's larger to hold an output frame that's
+ // larger.
+ //
+ // Sometimes the initiator is a participant only in the sense of wanting to
+ // keep an eye on success/failure to populate with buffers, and zx.status on
+ // failure. In that case, `has_constraints` can be false, and `constraints`
+ // will be ignored.
+ //
+ // VMO handles will not be provided to the client that sends null
+ // constraints - that can be intentional for an initiator that doesn't need
+ // VMO handles. Not having VMO handles doesn't prevent the initator from
+ // adjusting which portion of a buffer is considered valid and similar, but
+ // the initiator can't hold a VMO handle open to prevent the logical
+ // BufferCollection from cleaning up if the logical BufferCollection needs
+ // to go away regardless of the initiator's degree of involvement for
+ // whatever reason.
+ //
+ // For population of buffers to be attempted, all holders of a
+ // BufferCollection client channel need to call SetConstraints() before
+ // sysmem will attempt to allocate buffers.
+ //
+ // `has_constraints` if false, the constraints are effectively null, and
+ // `constraints` are ignored. The sender of null constraints won't get any
+ // VMO handles in BufferCollectionInfo, but can still find out how many
+ // buffers were allocated and can still refer to buffers by their
+ // buffer_index.
+ //
+ // `constraints` are constraints on the buffer collection.
+ // Request is heap-allocated.
+ ResultOf::SetConstraints SetConstraints(bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints);
+
+ // Provide BufferCollectionConstraints to the logical BufferCollection.
+ //
+ // Participants with read but not write can only call SetConstraints() once.
+ //
+ // Participants with write can call SetConstraints() more than once. The
+ // initial buffer allocation will use the constraints in the first call to
+ // SetConstraints(). Among other things, this allows a decoder to attempt
+ // to allocate a new buffer that's larger to hold an output frame that's
+ // larger.
+ //
+ // Sometimes the initiator is a participant only in the sense of wanting to
+ // keep an eye on success/failure to populate with buffers, and zx.status on
+ // failure. In that case, `has_constraints` can be false, and `constraints`
+ // will be ignored.
+ //
+ // VMO handles will not be provided to the client that sends null
+ // constraints - that can be intentional for an initiator that doesn't need
+ // VMO handles. Not having VMO handles doesn't prevent the initator from
+ // adjusting which portion of a buffer is considered valid and similar, but
+ // the initiator can't hold a VMO handle open to prevent the logical
+ // BufferCollection from cleaning up if the logical BufferCollection needs
+ // to go away regardless of the initiator's degree of involvement for
+ // whatever reason.
+ //
+ // For population of buffers to be attempted, all holders of a
+ // BufferCollection client channel need to call SetConstraints() before
+ // sysmem will attempt to allocate buffers.
+ //
+ // `has_constraints` if false, the constraints are effectively null, and
+ // `constraints` are ignored. The sender of null constraints won't get any
+ // VMO handles in BufferCollectionInfo, but can still find out how many
+ // buffers were allocated and can still refer to buffers by their
+ // buffer_index.
+ //
+ // `constraints` are constraints on the buffer collection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::SetConstraints SetConstraints(::fidl::BytePart _request_buffer, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints);
+
+ // This request completes when buffers have been allocated, responds with
+ // some failure detail if allocation has been attempted but failed.
+ //
+ // The following must occur before buffers will be allocated:
+ // * All BufferCollectionToken(s) of the logical BufferCollectionToken
+ // must be turned in via BindSharedCollection().
+ // * All BufferCollection(s) of the logical BufferCollection must have had
+ // SetConstraints() sent to them.
+ //
+ // A caller using C generated FIDL code who wishes not to block a thread in
+ // a zx_channel_call() for a potentially fairly long duration on this
+ // message/response can use SetEventSink() and
+ // BufferCollectionEvents.OnBuffersPopulated() instead.
+ //
+ // This method is still legal to call despite use of OnBuffersPopulated(),
+ // but in that case the additional BufferCollectionInfo returned here will
+ // include handles that are redundant with other handles in the
+ // BufferCollectionInfo delivered via OnBuffersPopulated() (separate handle
+ // but same underlying VMO objects), so most clients that bother calling
+ // SetEventSink() will prefer to receive BufferCollectionInfo via
+ // OnBuffersPopulated(). This method is mostly here for clients that don't
+ // call SetEventSink().
+ //
+ // Returns `ZX_OK` if successful.
+ // Returns `ZX_ERR_NO_MEMORY` if the request is valid but cannot be
+ // fulfilled due to resource exhaustion.
+ // Returns `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to
+ // obtain the buffers it requested.
+ // Returns `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // Returns `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be
+ // satisfied, perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` has the VMO handles and other related info.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::WaitForBuffersAllocated WaitForBuffersAllocated();
+
+ // This request completes when buffers have been allocated, responds with
+ // some failure detail if allocation has been attempted but failed.
+ //
+ // The following must occur before buffers will be allocated:
+ // * All BufferCollectionToken(s) of the logical BufferCollectionToken
+ // must be turned in via BindSharedCollection().
+ // * All BufferCollection(s) of the logical BufferCollection must have had
+ // SetConstraints() sent to them.
+ //
+ // A caller using C generated FIDL code who wishes not to block a thread in
+ // a zx_channel_call() for a potentially fairly long duration on this
+ // message/response can use SetEventSink() and
+ // BufferCollectionEvents.OnBuffersPopulated() instead.
+ //
+ // This method is still legal to call despite use of OnBuffersPopulated(),
+ // but in that case the additional BufferCollectionInfo returned here will
+ // include handles that are redundant with other handles in the
+ // BufferCollectionInfo delivered via OnBuffersPopulated() (separate handle
+ // but same underlying VMO objects), so most clients that bother calling
+ // SetEventSink() will prefer to receive BufferCollectionInfo via
+ // OnBuffersPopulated(). This method is mostly here for clients that don't
+ // call SetEventSink().
+ //
+ // Returns `ZX_OK` if successful.
+ // Returns `ZX_ERR_NO_MEMORY` if the request is valid but cannot be
+ // fulfilled due to resource exhaustion.
+ // Returns `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to
+ // obtain the buffers it requested.
+ // Returns `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // Returns `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be
+ // satisfied, perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` has the VMO handles and other related info.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WaitForBuffersAllocated WaitForBuffersAllocated(::fidl::BytePart _response_buffer);
+
+ // This returns the same result code as WaitForBuffersAllocated if the
+ // buffer collection has been allocated or failed, or `ZX_ERR_UNAVAILABLE`
+ // if WaitForBuffersAllocated would block.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CheckBuffersAllocated CheckBuffersAllocated();
+
+ // This returns the same result code as WaitForBuffersAllocated if the
+ // buffer collection has been allocated or failed, or `ZX_ERR_UNAVAILABLE`
+ // if WaitForBuffersAllocated would block.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CheckBuffersAllocated CheckBuffersAllocated(::fidl::BytePart _response_buffer);
+
+ // The CloseBuffer() doesn't immediately force all VMO handles to that
+ // buffer to close, but it does close any handle held by sysmem, and does
+ // notify all participants of the desire to close the buffer at which point
+ // each participant that's listening may close their handle to the buffer.
+ //
+ // Only a particpant with write can do this. Coordination among multiple
+ // participants with write is outside of the scope of this interface.
+ //
+ // `buffer_index` indicates which buffer to close. If the buffer is already
+ // closed this has no effect (idempotent).
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CloseSingleBuffer CloseSingleBuffer(uint64_t buffer_index);
+
+ // The CloseBuffer() doesn't immediately force all VMO handles to that
+ // buffer to close, but it does close any handle held by sysmem, and does
+ // notify all participants of the desire to close the buffer at which point
+ // each participant that's listening may close their handle to the buffer.
+ //
+ // Only a particpant with write can do this. Coordination among multiple
+ // participants with write is outside of the scope of this interface.
+ //
+ // `buffer_index` indicates which buffer to close. If the buffer is already
+ // closed this has no effect (idempotent).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CloseSingleBuffer CloseSingleBuffer(::fidl::BytePart _request_buffer, uint64_t buffer_index);
+
+ // This allocates a new buffer that is consistent with the most recent call
+ // to SetConstraints(), if possible. If not possible, this indicates the
+ // failure via OnNewBufferAllocated().
+ //
+ // Only a participant with write can do this. Coordination among multiple
+ // participants with write is outside the scope of this interface.
+ //
+ // The participant is (intentionally) never informed of other participant's
+ // constraints.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::AllocateSingleBuffer AllocateSingleBuffer(uint64_t buffer_index);
+
+ // This allocates a new buffer that is consistent with the most recent call
+ // to SetConstraints(), if possible. If not possible, this indicates the
+ // failure via OnNewBufferAllocated().
+ //
+ // Only a participant with write can do this. Coordination among multiple
+ // participants with write is outside the scope of this interface.
+ //
+ // The participant is (intentionally) never informed of other participant's
+ // constraints.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::AllocateSingleBuffer AllocateSingleBuffer(::fidl::BytePart _request_buffer, uint64_t buffer_index);
+
+ // Completes when AllocateBuffer is done. Callers who wish to avoid
+ // blocking a thread while waiting can use OnAllocateSingleBufferDone()
+ // instead.
+ // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::WaitForSingleBufferAllocated WaitForSingleBufferAllocated(uint64_t buffer_index);
+
+ // Completes when AllocateBuffer is done. Callers who wish to avoid
+ // blocking a thread while waiting can use OnAllocateSingleBufferDone()
+ // instead.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::WaitForSingleBufferAllocated WaitForSingleBufferAllocated(::fidl::BytePart _request_buffer, uint64_t buffer_index, ::fidl::BytePart _response_buffer);
+
+ // A participant can use this message to have sysmem verify that this
+ // buffer_index exists. This message is intentionally ignored by the
+ // server if the buffer_index _does_ exist. In that case, the client will
+ // see OnAllocateSingleBufferDone() soon with status == `ZX_OK` (if the
+ // client hasn't already seen that message). If on the other hand the
+ // buffer_index does not exist, this message causes the server to send
+ // OnAllocateSingleBufferDone() with status == `ZX_ERR_NOT_FOUND`. A
+ // particpant will typically use this when the participant receives a new
+ // buffer_index that the participant doesn't yet know about, to ensure that
+ // the participant won't be waiting forever for the
+ // OnAllocateSingleBufferDone() message regarding this buffer_index.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CheckSingleBufferAllocated CheckSingleBufferAllocated(uint64_t buffer_index);
+
+ // A participant can use this message to have sysmem verify that this
+ // buffer_index exists. This message is intentionally ignored by the
+ // server if the buffer_index _does_ exist. In that case, the client will
+ // see OnAllocateSingleBufferDone() soon with status == `ZX_OK` (if the
+ // client hasn't already seen that message). If on the other hand the
+ // buffer_index does not exist, this message causes the server to send
+ // OnAllocateSingleBufferDone() with status == `ZX_ERR_NOT_FOUND`. A
+ // particpant will typically use this when the participant receives a new
+ // buffer_index that the participant doesn't yet know about, to ensure that
+ // the participant won't be waiting forever for the
+ // OnAllocateSingleBufferDone() message regarding this buffer_index.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CheckSingleBufferAllocated CheckSingleBufferAllocated(::fidl::BytePart _request_buffer, uint64_t buffer_index);
+
+ // The server handles unexpected failure of a BufferCollection by failing
+ // the whole LogicalBufferCollection. Partly this is to expedite closing
+ // VMO handles. If a participant would like to cleanly close a
+ // BufferCollection view without causing LogicalBufferCollection failure,
+ // the participant can send Close() before closing the client end of the
+ // BufferCollection channel. If this is the last BufferCollection view, the
+ // LogicalBufferCollection will still go away.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+
+ 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:
+
+ // At least for now, the only way to get events from a BufferCollection is
+ // to set a reverse BufferCollectionEvents channel. This can be sent up to
+ // once at any point during BufferCollection channel lifetime. All events
+ // are one-shot events, and will be sent immediately via `events` if the
+ // one-shot event's condition has already become true (once true will stay
+ // true; only goes from false to true once).
+ //
+ // `events` is the client end of a BufferCollectionEvents which will be sent
+ // one-way messages indicating events relevant to this BufferCollection
+ // channel (some may be specific to this BufferCollection channel and some
+ // may be relevant to the overall logical BufferCollection).
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::SetEventSink SetEventSink(::zx::unowned_channel _client_end, ::zx::channel events);
+
+ // At least for now, the only way to get events from a BufferCollection is
+ // to set a reverse BufferCollectionEvents channel. This can be sent up to
+ // once at any point during BufferCollection channel lifetime. All events
+ // are one-shot events, and will be sent immediately via `events` if the
+ // one-shot event's condition has already become true (once true will stay
+ // true; only goes from false to true once).
+ //
+ // `events` is the client end of a BufferCollectionEvents which will be sent
+ // one-way messages indicating events relevant to this BufferCollection
+ // channel (some may be specific to this BufferCollection channel and some
+ // may be relevant to the overall logical BufferCollection).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetEventSink SetEventSink(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel events);
+
+ // See comments on BufferCollectionToken::Sync().
+ // Allocates 32 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Sync Sync(::zx::unowned_channel _client_end);
+
+
+ // Provide BufferCollectionConstraints to the logical BufferCollection.
+ //
+ // Participants with read but not write can only call SetConstraints() once.
+ //
+ // Participants with write can call SetConstraints() more than once. The
+ // initial buffer allocation will use the constraints in the first call to
+ // SetConstraints(). Among other things, this allows a decoder to attempt
+ // to allocate a new buffer that's larger to hold an output frame that's
+ // larger.
+ //
+ // Sometimes the initiator is a participant only in the sense of wanting to
+ // keep an eye on success/failure to populate with buffers, and zx.status on
+ // failure. In that case, `has_constraints` can be false, and `constraints`
+ // will be ignored.
+ //
+ // VMO handles will not be provided to the client that sends null
+ // constraints - that can be intentional for an initiator that doesn't need
+ // VMO handles. Not having VMO handles doesn't prevent the initator from
+ // adjusting which portion of a buffer is considered valid and similar, but
+ // the initiator can't hold a VMO handle open to prevent the logical
+ // BufferCollection from cleaning up if the logical BufferCollection needs
+ // to go away regardless of the initiator's degree of involvement for
+ // whatever reason.
+ //
+ // For population of buffers to be attempted, all holders of a
+ // BufferCollection client channel need to call SetConstraints() before
+ // sysmem will attempt to allocate buffers.
+ //
+ // `has_constraints` if false, the constraints are effectively null, and
+ // `constraints` are ignored. The sender of null constraints won't get any
+ // VMO handles in BufferCollectionInfo, but can still find out how many
+ // buffers were allocated and can still refer to buffers by their
+ // buffer_index.
+ //
+ // `constraints` are constraints on the buffer collection.
+ // Request is heap-allocated.
+ static ResultOf::SetConstraints SetConstraints(::zx::unowned_channel _client_end, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints);
+
+ // Provide BufferCollectionConstraints to the logical BufferCollection.
+ //
+ // Participants with read but not write can only call SetConstraints() once.
+ //
+ // Participants with write can call SetConstraints() more than once. The
+ // initial buffer allocation will use the constraints in the first call to
+ // SetConstraints(). Among other things, this allows a decoder to attempt
+ // to allocate a new buffer that's larger to hold an output frame that's
+ // larger.
+ //
+ // Sometimes the initiator is a participant only in the sense of wanting to
+ // keep an eye on success/failure to populate with buffers, and zx.status on
+ // failure. In that case, `has_constraints` can be false, and `constraints`
+ // will be ignored.
+ //
+ // VMO handles will not be provided to the client that sends null
+ // constraints - that can be intentional for an initiator that doesn't need
+ // VMO handles. Not having VMO handles doesn't prevent the initator from
+ // adjusting which portion of a buffer is considered valid and similar, but
+ // the initiator can't hold a VMO handle open to prevent the logical
+ // BufferCollection from cleaning up if the logical BufferCollection needs
+ // to go away regardless of the initiator's degree of involvement for
+ // whatever reason.
+ //
+ // For population of buffers to be attempted, all holders of a
+ // BufferCollection client channel need to call SetConstraints() before
+ // sysmem will attempt to allocate buffers.
+ //
+ // `has_constraints` if false, the constraints are effectively null, and
+ // `constraints` are ignored. The sender of null constraints won't get any
+ // VMO handles in BufferCollectionInfo, but can still find out how many
+ // buffers were allocated and can still refer to buffers by their
+ // buffer_index.
+ //
+ // `constraints` are constraints on the buffer collection.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::SetConstraints SetConstraints(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints);
+
+ // This request completes when buffers have been allocated, responds with
+ // some failure detail if allocation has been attempted but failed.
+ //
+ // The following must occur before buffers will be allocated:
+ // * All BufferCollectionToken(s) of the logical BufferCollectionToken
+ // must be turned in via BindSharedCollection().
+ // * All BufferCollection(s) of the logical BufferCollection must have had
+ // SetConstraints() sent to them.
+ //
+ // A caller using C generated FIDL code who wishes not to block a thread in
+ // a zx_channel_call() for a potentially fairly long duration on this
+ // message/response can use SetEventSink() and
+ // BufferCollectionEvents.OnBuffersPopulated() instead.
+ //
+ // This method is still legal to call despite use of OnBuffersPopulated(),
+ // but in that case the additional BufferCollectionInfo returned here will
+ // include handles that are redundant with other handles in the
+ // BufferCollectionInfo delivered via OnBuffersPopulated() (separate handle
+ // but same underlying VMO objects), so most clients that bother calling
+ // SetEventSink() will prefer to receive BufferCollectionInfo via
+ // OnBuffersPopulated(). This method is mostly here for clients that don't
+ // call SetEventSink().
+ //
+ // Returns `ZX_OK` if successful.
+ // Returns `ZX_ERR_NO_MEMORY` if the request is valid but cannot be
+ // fulfilled due to resource exhaustion.
+ // Returns `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to
+ // obtain the buffers it requested.
+ // Returns `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // Returns `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be
+ // satisfied, perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` has the VMO handles and other related info.
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::WaitForBuffersAllocated WaitForBuffersAllocated(::zx::unowned_channel _client_end);
+
+ // This request completes when buffers have been allocated, responds with
+ // some failure detail if allocation has been attempted but failed.
+ //
+ // The following must occur before buffers will be allocated:
+ // * All BufferCollectionToken(s) of the logical BufferCollectionToken
+ // must be turned in via BindSharedCollection().
+ // * All BufferCollection(s) of the logical BufferCollection must have had
+ // SetConstraints() sent to them.
+ //
+ // A caller using C generated FIDL code who wishes not to block a thread in
+ // a zx_channel_call() for a potentially fairly long duration on this
+ // message/response can use SetEventSink() and
+ // BufferCollectionEvents.OnBuffersPopulated() instead.
+ //
+ // This method is still legal to call despite use of OnBuffersPopulated(),
+ // but in that case the additional BufferCollectionInfo returned here will
+ // include handles that are redundant with other handles in the
+ // BufferCollectionInfo delivered via OnBuffersPopulated() (separate handle
+ // but same underlying VMO objects), so most clients that bother calling
+ // SetEventSink() will prefer to receive BufferCollectionInfo via
+ // OnBuffersPopulated(). This method is mostly here for clients that don't
+ // call SetEventSink().
+ //
+ // Returns `ZX_OK` if successful.
+ // Returns `ZX_ERR_NO_MEMORY` if the request is valid but cannot be
+ // fulfilled due to resource exhaustion.
+ // Returns `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to
+ // obtain the buffers it requested.
+ // Returns `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // Returns `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be
+ // satisfied, perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` has the VMO handles and other related info.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WaitForBuffersAllocated WaitForBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // This returns the same result code as WaitForBuffersAllocated if the
+ // buffer collection has been allocated or failed, or `ZX_ERR_UNAVAILABLE`
+ // if WaitForBuffersAllocated would block.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CheckBuffersAllocated CheckBuffersAllocated(::zx::unowned_channel _client_end);
+
+ // This returns the same result code as WaitForBuffersAllocated if the
+ // buffer collection has been allocated or failed, or `ZX_ERR_UNAVAILABLE`
+ // if WaitForBuffersAllocated would block.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CheckBuffersAllocated CheckBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // The CloseBuffer() doesn't immediately force all VMO handles to that
+ // buffer to close, but it does close any handle held by sysmem, and does
+ // notify all participants of the desire to close the buffer at which point
+ // each participant that's listening may close their handle to the buffer.
+ //
+ // Only a particpant with write can do this. Coordination among multiple
+ // participants with write is outside of the scope of this interface.
+ //
+ // `buffer_index` indicates which buffer to close. If the buffer is already
+ // closed this has no effect (idempotent).
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CloseSingleBuffer CloseSingleBuffer(::zx::unowned_channel _client_end, uint64_t buffer_index);
+
+ // The CloseBuffer() doesn't immediately force all VMO handles to that
+ // buffer to close, but it does close any handle held by sysmem, and does
+ // notify all participants of the desire to close the buffer at which point
+ // each participant that's listening may close their handle to the buffer.
+ //
+ // Only a particpant with write can do this. Coordination among multiple
+ // participants with write is outside of the scope of this interface.
+ //
+ // `buffer_index` indicates which buffer to close. If the buffer is already
+ // closed this has no effect (idempotent).
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CloseSingleBuffer CloseSingleBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index);
+
+ // This allocates a new buffer that is consistent with the most recent call
+ // to SetConstraints(), if possible. If not possible, this indicates the
+ // failure via OnNewBufferAllocated().
+ //
+ // Only a participant with write can do this. Coordination among multiple
+ // participants with write is outside the scope of this interface.
+ //
+ // The participant is (intentionally) never informed of other participant's
+ // constraints.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::AllocateSingleBuffer AllocateSingleBuffer(::zx::unowned_channel _client_end, uint64_t buffer_index);
+
+ // This allocates a new buffer that is consistent with the most recent call
+ // to SetConstraints(), if possible. If not possible, this indicates the
+ // failure via OnNewBufferAllocated().
+ //
+ // Only a participant with write can do this. Coordination among multiple
+ // participants with write is outside the scope of this interface.
+ //
+ // The participant is (intentionally) never informed of other participant's
+ // constraints.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::AllocateSingleBuffer AllocateSingleBuffer(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index);
+
+ // Completes when AllocateBuffer is done. Callers who wish to avoid
+ // blocking a thread while waiting can use OnAllocateSingleBufferDone()
+ // instead.
+ // Allocates 328 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::WaitForSingleBufferAllocated WaitForSingleBufferAllocated(::zx::unowned_channel _client_end, uint64_t buffer_index);
+
+ // Completes when AllocateBuffer is done. Callers who wish to avoid
+ // blocking a thread while waiting can use OnAllocateSingleBufferDone()
+ // instead.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::WaitForSingleBufferAllocated WaitForSingleBufferAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index, ::fidl::BytePart _response_buffer);
+
+ // A participant can use this message to have sysmem verify that this
+ // buffer_index exists. This message is intentionally ignored by the
+ // server if the buffer_index _does_ exist. In that case, the client will
+ // see OnAllocateSingleBufferDone() soon with status == `ZX_OK` (if the
+ // client hasn't already seen that message). If on the other hand the
+ // buffer_index does not exist, this message causes the server to send
+ // OnAllocateSingleBufferDone() with status == `ZX_ERR_NOT_FOUND`. A
+ // particpant will typically use this when the participant receives a new
+ // buffer_index that the participant doesn't yet know about, to ensure that
+ // the participant won't be waiting forever for the
+ // OnAllocateSingleBufferDone() message regarding this buffer_index.
+ // Allocates 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CheckSingleBufferAllocated CheckSingleBufferAllocated(::zx::unowned_channel _client_end, uint64_t buffer_index);
+
+ // A participant can use this message to have sysmem verify that this
+ // buffer_index exists. This message is intentionally ignored by the
+ // server if the buffer_index _does_ exist. In that case, the client will
+ // see OnAllocateSingleBufferDone() soon with status == `ZX_OK` (if the
+ // client hasn't already seen that message). If on the other hand the
+ // buffer_index does not exist, this message causes the server to send
+ // OnAllocateSingleBufferDone() with status == `ZX_ERR_NOT_FOUND`. A
+ // particpant will typically use this when the participant receives a new
+ // buffer_index that the participant doesn't yet know about, to ensure that
+ // the participant won't be waiting forever for the
+ // OnAllocateSingleBufferDone() message regarding this buffer_index.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CheckSingleBufferAllocated CheckSingleBufferAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint64_t buffer_index);
+
+ // The server handles unexpected failure of a BufferCollection by failing
+ // the whole LogicalBufferCollection. Partly this is to expedite closing
+ // VMO handles. If a participant would like to cleanly close a
+ // BufferCollection view without causing LogicalBufferCollection failure,
+ // the participant can send Close() before closing the client end of the
+ // BufferCollection channel. If this is the last BufferCollection view, the
+ // LogicalBufferCollection will still go away.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+
+ };
+
+ // 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:
+
+ // At least for now, the only way to get events from a BufferCollection is
+ // to set a reverse BufferCollectionEvents channel. This can be sent up to
+ // once at any point during BufferCollection channel lifetime. All events
+ // are one-shot events, and will be sent immediately via `events` if the
+ // one-shot event's condition has already become true (once true will stay
+ // true; only goes from false to true once).
+ //
+ // `events` is the client end of a BufferCollectionEvents which will be sent
+ // one-way messages indicating events relevant to this BufferCollection
+ // channel (some may be specific to this BufferCollection channel and some
+ // may be relevant to the overall logical BufferCollection).
+ static ::fidl::internal::StatusAndError SetEventSink(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetEventSinkRequest> params);
+
+ // See comments on BufferCollectionToken::Sync().
+ static ::fidl::DecodeResult<SyncResponse> Sync(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Provide BufferCollectionConstraints to the logical BufferCollection.
+ //
+ // Participants with read but not write can only call SetConstraints() once.
+ //
+ // Participants with write can call SetConstraints() more than once. The
+ // initial buffer allocation will use the constraints in the first call to
+ // SetConstraints(). Among other things, this allows a decoder to attempt
+ // to allocate a new buffer that's larger to hold an output frame that's
+ // larger.
+ //
+ // Sometimes the initiator is a participant only in the sense of wanting to
+ // keep an eye on success/failure to populate with buffers, and zx.status on
+ // failure. In that case, `has_constraints` can be false, and `constraints`
+ // will be ignored.
+ //
+ // VMO handles will not be provided to the client that sends null
+ // constraints - that can be intentional for an initiator that doesn't need
+ // VMO handles. Not having VMO handles doesn't prevent the initator from
+ // adjusting which portion of a buffer is considered valid and similar, but
+ // the initiator can't hold a VMO handle open to prevent the logical
+ // BufferCollection from cleaning up if the logical BufferCollection needs
+ // to go away regardless of the initiator's degree of involvement for
+ // whatever reason.
+ //
+ // For population of buffers to be attempted, all holders of a
+ // BufferCollection client channel need to call SetConstraints() before
+ // sysmem will attempt to allocate buffers.
+ //
+ // `has_constraints` if false, the constraints are effectively null, and
+ // `constraints` are ignored. The sender of null constraints won't get any
+ // VMO handles in BufferCollectionInfo, but can still find out how many
+ // buffers were allocated and can still refer to buffers by their
+ // buffer_index.
+ //
+ // `constraints` are constraints on the buffer collection.
+ static ::fidl::internal::StatusAndError SetConstraints(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<SetConstraintsRequest> params);
+
+ // This request completes when buffers have been allocated, responds with
+ // some failure detail if allocation has been attempted but failed.
+ //
+ // The following must occur before buffers will be allocated:
+ // * All BufferCollectionToken(s) of the logical BufferCollectionToken
+ // must be turned in via BindSharedCollection().
+ // * All BufferCollection(s) of the logical BufferCollection must have had
+ // SetConstraints() sent to them.
+ //
+ // A caller using C generated FIDL code who wishes not to block a thread in
+ // a zx_channel_call() for a potentially fairly long duration on this
+ // message/response can use SetEventSink() and
+ // BufferCollectionEvents.OnBuffersPopulated() instead.
+ //
+ // This method is still legal to call despite use of OnBuffersPopulated(),
+ // but in that case the additional BufferCollectionInfo returned here will
+ // include handles that are redundant with other handles in the
+ // BufferCollectionInfo delivered via OnBuffersPopulated() (separate handle
+ // but same underlying VMO objects), so most clients that bother calling
+ // SetEventSink() will prefer to receive BufferCollectionInfo via
+ // OnBuffersPopulated(). This method is mostly here for clients that don't
+ // call SetEventSink().
+ //
+ // Returns `ZX_OK` if successful.
+ // Returns `ZX_ERR_NO_MEMORY` if the request is valid but cannot be
+ // fulfilled due to resource exhaustion.
+ // Returns `ZX_ERR_ACCESS_DENIED` if the caller is not permitted to
+ // obtain the buffers it requested.
+ // Returns `ZX_ERR_INVALID_ARGS` if the request is malformed.
+ // Returns `ZX_ERR_NOT_SUPPORTED` if request is valid but cannot be
+ // satisfied, perhaps due to hardware limitations.
+ //
+ // `buffer_collection_info` has the VMO handles and other related info.
+ static ::fidl::DecodeResult<WaitForBuffersAllocatedResponse> WaitForBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // This returns the same result code as WaitForBuffersAllocated if the
+ // buffer collection has been allocated or failed, or `ZX_ERR_UNAVAILABLE`
+ // if WaitForBuffersAllocated would block.
+ static ::fidl::DecodeResult<CheckBuffersAllocatedResponse> CheckBuffersAllocated(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // The CloseBuffer() doesn't immediately force all VMO handles to that
+ // buffer to close, but it does close any handle held by sysmem, and does
+ // notify all participants of the desire to close the buffer at which point
+ // each participant that's listening may close their handle to the buffer.
+ //
+ // Only a particpant with write can do this. Coordination among multiple
+ // participants with write is outside of the scope of this interface.
+ //
+ // `buffer_index` indicates which buffer to close. If the buffer is already
+ // closed this has no effect (idempotent).
+ static ::fidl::internal::StatusAndError CloseSingleBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloseSingleBufferRequest> params);
+
+ // This allocates a new buffer that is consistent with the most recent call
+ // to SetConstraints(), if possible. If not possible, this indicates the
+ // failure via OnNewBufferAllocated().
+ //
+ // Only a participant with write can do this. Coordination among multiple
+ // participants with write is outside the scope of this interface.
+ //
+ // The participant is (intentionally) never informed of other participant's
+ // constraints.
+ static ::fidl::internal::StatusAndError AllocateSingleBuffer(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<AllocateSingleBufferRequest> params);
+
+ // Completes when AllocateBuffer is done. Callers who wish to avoid
+ // blocking a thread while waiting can use OnAllocateSingleBufferDone()
+ // instead.
+ static ::fidl::DecodeResult<WaitForSingleBufferAllocatedResponse> WaitForSingleBufferAllocated(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<WaitForSingleBufferAllocatedRequest> params, ::fidl::BytePart response_buffer);
+
+ // A participant can use this message to have sysmem verify that this
+ // buffer_index exists. This message is intentionally ignored by the
+ // server if the buffer_index _does_ exist. In that case, the client will
+ // see OnAllocateSingleBufferDone() soon with status == `ZX_OK` (if the
+ // client hasn't already seen that message). If on the other hand the
+ // buffer_index does not exist, this message causes the server to send
+ // OnAllocateSingleBufferDone() with status == `ZX_ERR_NOT_FOUND`. A
+ // particpant will typically use this when the participant receives a new
+ // buffer_index that the participant doesn't yet know about, to ensure that
+ // the participant won't be waiting forever for the
+ // OnAllocateSingleBufferDone() message regarding this buffer_index.
+ static ::fidl::internal::StatusAndError CheckSingleBufferAllocated(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CheckSingleBufferAllocatedRequest> params);
+
+ // The server handles unexpected failure of a BufferCollection by failing
+ // the whole LogicalBufferCollection. Partly this is to expedite closing
+ // VMO handles. If a participant would like to cleanly close a
+ // BufferCollection view without causing LogicalBufferCollection failure,
+ // the participant can send Close() before closing the client end of the
+ // BufferCollection channel. If this is the last BufferCollection view, the
+ // LogicalBufferCollection will still go away.
+ static ::fidl::internal::StatusAndError Close(::zx::unowned_channel _client_end);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = BufferCollection;
+ using _Base = ::fidl::CompleterBase;
+
+ using SetEventSinkCompleter = ::fidl::Completer<>;
+
+ virtual void SetEventSink(::zx::channel events, SetEventSinkCompleter::Sync _completer) = 0;
+
+ class SyncCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using SyncCompleter = ::fidl::Completer<SyncCompleterBase>;
+
+ virtual void Sync(SyncCompleter::Sync _completer) = 0;
+
+ using SetConstraintsCompleter = ::fidl::Completer<>;
+
+ virtual void SetConstraints(bool has_constraints, ::llcpp::fuchsia::sysmem::BufferCollectionConstraints constraints, SetConstraintsCompleter::Sync _completer) = 0;
+
+ class WaitForBuffersAllocatedCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2 buffer_collection_info);
+ void Reply(::fidl::DecodedMessage<WaitForBuffersAllocatedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WaitForBuffersAllocatedCompleter = ::fidl::Completer<WaitForBuffersAllocatedCompleterBase>;
+
+ virtual void WaitForBuffersAllocated(WaitForBuffersAllocatedCompleter::Sync _completer) = 0;
+
+ class CheckBuffersAllocatedCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status);
+ void Reply(::fidl::BytePart _buffer, int32_t status);
+ void Reply(::fidl::DecodedMessage<CheckBuffersAllocatedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CheckBuffersAllocatedCompleter = ::fidl::Completer<CheckBuffersAllocatedCompleterBase>;
+
+ virtual void CheckBuffersAllocated(CheckBuffersAllocatedCompleter::Sync _completer) = 0;
+
+ using CloseSingleBufferCompleter = ::fidl::Completer<>;
+
+ virtual void CloseSingleBuffer(uint64_t buffer_index, CloseSingleBufferCompleter::Sync _completer) = 0;
+
+ using AllocateSingleBufferCompleter = ::fidl::Completer<>;
+
+ virtual void AllocateSingleBuffer(uint64_t buffer_index, AllocateSingleBufferCompleter::Sync _completer) = 0;
+
+ class WaitForSingleBufferAllocatedCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info);
+ void Reply(::fidl::BytePart _buffer, int32_t status, ::llcpp::fuchsia::sysmem::SingleBufferInfo buffer_info);
+ void Reply(::fidl::DecodedMessage<WaitForSingleBufferAllocatedResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using WaitForSingleBufferAllocatedCompleter = ::fidl::Completer<WaitForSingleBufferAllocatedCompleterBase>;
+
+ virtual void WaitForSingleBufferAllocated(uint64_t buffer_index, WaitForSingleBufferAllocatedCompleter::Sync _completer) = 0;
+
+ using CheckSingleBufferAllocatedCompleter = ::fidl::Completer<>;
+
+ virtual void CheckSingleBufferAllocated(uint64_t buffer_index, CheckSingleBufferAllocatedCompleter::Sync _completer) = 0;
+
+ using CloseCompleter = ::fidl::Completer<>;
+
+ virtual void Close(CloseCompleter::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 SetEventSinkRequest(const ::fidl::DecodedMessage<BufferCollection::SetEventSinkRequest>& _msg);
+ static void SyncRequest(const ::fidl::DecodedMessage<BufferCollection::SyncRequest>& _msg);
+ static void SyncResponse(const ::fidl::DecodedMessage<BufferCollection::SyncResponse>& _msg);
+ static void SetConstraintsRequest(const ::fidl::DecodedMessage<BufferCollection::SetConstraintsRequest>& _msg);
+ static void WaitForBuffersAllocatedRequest(const ::fidl::DecodedMessage<BufferCollection::WaitForBuffersAllocatedRequest>& _msg);
+ static void WaitForBuffersAllocatedResponse(const ::fidl::DecodedMessage<BufferCollection::WaitForBuffersAllocatedResponse>& _msg);
+ static void CheckBuffersAllocatedRequest(const ::fidl::DecodedMessage<BufferCollection::CheckBuffersAllocatedRequest>& _msg);
+ static void CheckBuffersAllocatedResponse(const ::fidl::DecodedMessage<BufferCollection::CheckBuffersAllocatedResponse>& _msg);
+ static void CloseSingleBufferRequest(const ::fidl::DecodedMessage<BufferCollection::CloseSingleBufferRequest>& _msg);
+ static void AllocateSingleBufferRequest(const ::fidl::DecodedMessage<BufferCollection::AllocateSingleBufferRequest>& _msg);
+ static void WaitForSingleBufferAllocatedRequest(const ::fidl::DecodedMessage<BufferCollection::WaitForSingleBufferAllocatedRequest>& _msg);
+ static void WaitForSingleBufferAllocatedResponse(const ::fidl::DecodedMessage<BufferCollection::WaitForSingleBufferAllocatedResponse>& _msg);
+ static void CheckSingleBufferAllocatedRequest(const ::fidl::DecodedMessage<BufferCollection::CheckSingleBufferAllocatedRequest>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<BufferCollection::CloseRequest>& _msg);
+ };
+};
+
+} // namespace sysmem
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::VmoBuffer> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::VmoBuffer>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::VmoBuffer, vmo) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::VmoBuffer, vmo_usable_start) == 8);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::VmoBuffer) == ::llcpp::fuchsia::sysmem::VmoBuffer::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollectionToken::DuplicateRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollectionToken::DuplicateRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollectionToken::DuplicateRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollectionToken::DuplicateRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionToken::DuplicateRequest, rights_attenuation_mask) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionToken::DuplicateRequest, token_request) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::Heap::AllocateVmoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::Heap::AllocateVmoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::Heap::AllocateVmoRequest)
+ == ::llcpp::fuchsia::sysmem::Heap::AllocateVmoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Heap::AllocateVmoRequest, size) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::Heap::AllocateVmoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::Heap::AllocateVmoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::Heap::AllocateVmoResponse)
+ == ::llcpp::fuchsia::sysmem::Heap::AllocateVmoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Heap::AllocateVmoResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Heap::AllocateVmoResponse, vmo) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::Heap::CreateResourceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::Heap::CreateResourceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::Heap::CreateResourceRequest)
+ == ::llcpp::fuchsia::sysmem::Heap::CreateResourceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Heap::CreateResourceRequest, vmo) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::Heap::CreateResourceResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::Heap::CreateResourceResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::Heap::CreateResourceResponse)
+ == ::llcpp::fuchsia::sysmem::Heap::CreateResourceResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Heap::CreateResourceResponse, s) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Heap::CreateResourceResponse, id) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::Heap::DestroyResourceRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::Heap::DestroyResourceRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::Heap::DestroyResourceRequest)
+ == ::llcpp::fuchsia::sysmem::Heap::DestroyResourceRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Heap::DestroyResourceRequest, id) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::DriverConnector::ConnectRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::DriverConnector::ConnectRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::DriverConnector::ConnectRequest)
+ == ::llcpp::fuchsia::sysmem::DriverConnector::ConnectRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::DriverConnector::ConnectRequest, allocator_request) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::Allocator::AllocateNonSharedCollectionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::Allocator::AllocateNonSharedCollectionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::Allocator::AllocateNonSharedCollectionRequest)
+ == ::llcpp::fuchsia::sysmem::Allocator::AllocateNonSharedCollectionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Allocator::AllocateNonSharedCollectionRequest, collection) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::Allocator::AllocateSharedCollectionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::Allocator::AllocateSharedCollectionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::Allocator::AllocateSharedCollectionRequest)
+ == ::llcpp::fuchsia::sysmem::Allocator::AllocateSharedCollectionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Allocator::AllocateSharedCollectionRequest, token_request) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::Allocator::BindSharedCollectionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::Allocator::BindSharedCollectionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::Allocator::BindSharedCollectionRequest)
+ == ::llcpp::fuchsia::sysmem::Allocator::BindSharedCollectionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Allocator::BindSharedCollectionRequest, token) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::Allocator::BindSharedCollectionRequest, buffer_collection_request) == 20);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response) == ::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::SecureMem_SetPhysicalSecureHeaps_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::ImagePlane> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::ImagePlane>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImagePlane, byte_offset) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImagePlane, bytes_per_row) == 4);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::ImagePlane) == ::llcpp::fuchsia::sysmem::ImagePlane::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::PhysicalSecureHeap> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::PhysicalSecureHeap>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::PhysicalSecureHeap, heap) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::PhysicalSecureHeap, physical_address) == 8);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::PhysicalSecureHeap, size_bytes) == 16);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::PhysicalSecureHeap) == ::llcpp::fuchsia::sysmem::PhysicalSecureHeap::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::PhysicalSecureHeaps> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::PhysicalSecureHeaps>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::PhysicalSecureHeaps, heaps_count) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::PhysicalSecureHeaps, heaps) == 8);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::PhysicalSecureHeaps) == ::llcpp::fuchsia::sysmem::PhysicalSecureHeaps::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response, heaps) == 0);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response) == ::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Response::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Result> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::SecureMem_GetPhysicalSecureHeaps_Result>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SecureMem::GetPhysicalSecureHeapsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::SecureMem::GetPhysicalSecureHeapsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::SecureMem::GetPhysicalSecureHeapsResponse)
+ == ::llcpp::fuchsia::sysmem::SecureMem::GetPhysicalSecureHeapsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SecureMem::GetPhysicalSecureHeapsResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsRequest)
+ == ::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsRequest, heaps) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsResponse)
+ == ::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SecureMem::SetPhysicalSecureHeapsResponse, result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferMemoryConstraints> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::BufferMemoryConstraints>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, min_size_bytes) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, max_size_bytes) == 4);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, physically_contiguous_required) == 8);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, secure_required) == 9);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, ram_domain_supported) == 10);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, cpu_domain_supported) == 11);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, inaccessible_domain_supported) == 12);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, heap_permitted_count) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints, heap_permitted) == 24);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferMemoryConstraints) == ::llcpp::fuchsia::sysmem::BufferMemoryConstraints::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::FormatModifier> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::FormatModifier>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::FormatModifier, value) == 0);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::FormatModifier) == ::llcpp::fuchsia::sysmem::FormatModifier::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::PixelFormat> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::PixelFormat>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::PixelFormat, type) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::PixelFormat, has_format_modifier) == 4);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::PixelFormat, format_modifier) == 8);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::PixelFormat) == ::llcpp::fuchsia::sysmem::PixelFormat::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::ColorSpace> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::ColorSpace>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ColorSpace, type) == 0);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::ColorSpace) == ::llcpp::fuchsia::sysmem::ColorSpace::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::ImageSpec> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::ImageSpec>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageSpec, min_width) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageSpec, min_height) == 4);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageSpec, layers) == 8);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageSpec, pixel_format) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageSpec, color_space) == 32);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::ImageSpec) == ::llcpp::fuchsia::sysmem::ImageSpec::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::ImageFormat_2> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::ImageFormat_2>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, pixel_format) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, coded_width) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, coded_height) == 20);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, bytes_per_row) == 24);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, display_width) == 28);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, display_height) == 32);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, layers) == 36);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, color_space) == 40);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, has_pixel_aspect_ratio) == 44);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, pixel_aspect_ratio_width) == 48);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat_2, pixel_aspect_ratio_height) == 52);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::ImageFormat_2) == ::llcpp::fuchsia::sysmem::ImageFormat_2::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::ImageFormatConstraints> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::ImageFormatConstraints>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, pixel_format) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, color_spaces_count) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, color_space) == 20);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, min_coded_width) == 148);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, max_coded_width) == 152);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, min_coded_height) == 156);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, max_coded_height) == 160);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, min_bytes_per_row) == 164);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, max_bytes_per_row) == 168);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, max_coded_width_times_coded_height) == 172);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, layers) == 176);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, coded_width_divisor) == 180);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, coded_height_divisor) == 184);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, bytes_per_row_divisor) == 188);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, start_offset_divisor) == 192);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, display_width_divisor) == 196);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, display_height_divisor) == 200);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, required_min_coded_width) == 204);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, required_max_coded_width) == 208);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, required_min_coded_height) == 212);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, required_max_coded_height) == 216);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, required_min_bytes_per_row) == 220);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormatConstraints, required_max_bytes_per_row) == 224);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::ImageFormatConstraints) == ::llcpp::fuchsia::sysmem::ImageFormatConstraints::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::ImageFormat> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::ImageFormat>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat, width) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat, height) == 4);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat, layers) == 8);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat, pixel_format) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat, color_space) == 32);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::ImageFormat, planes) == 36);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::ImageFormat) == ::llcpp::fuchsia::sysmem::ImageFormat::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferFormat> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::BufferFormat>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferFormat, tag) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferFormat, image) == 8);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferFormat) == ::llcpp::fuchsia::sysmem::BufferFormat::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollectionInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::BufferCollectionInfo>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionInfo, buffer_count) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionInfo, format) == 8);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionInfo, vmos) == 88);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionInfo, vmo_size) == 344);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollectionInfo) == ::llcpp::fuchsia::sysmem::BufferCollectionInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferMemorySettings> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::BufferMemorySettings>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemorySettings, size_bytes) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemorySettings, is_physically_contiguous) == 4);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemorySettings, is_secure) == 5);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemorySettings, coherency_domain) == 8);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferMemorySettings, heap) == 16);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferMemorySettings) == ::llcpp::fuchsia::sysmem::BufferMemorySettings::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SingleBufferSettings> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::SingleBufferSettings>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SingleBufferSettings, buffer_settings) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SingleBufferSettings, has_image_format_constraints) == 24);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SingleBufferSettings, image_format_constraints) == 32);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::SingleBufferSettings) == ::llcpp::fuchsia::sysmem::SingleBufferSettings::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::SingleBufferInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::SingleBufferInfo>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SingleBufferInfo, settings) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::SingleBufferInfo, buffer) == 264);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::SingleBufferInfo) == ::llcpp::fuchsia::sysmem::SingleBufferInfo::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollectionInfo_2> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::BufferCollectionInfo_2>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionInfo_2, buffer_count) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionInfo_2, settings) == 8);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionInfo_2, buffers) == 272);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollectionInfo_2) == ::llcpp::fuchsia::sysmem::BufferCollectionInfo_2::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnBuffersAllocatedRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnBuffersAllocatedRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnBuffersAllocatedRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnBuffersAllocatedRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnBuffersAllocatedRequest, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnBuffersAllocatedRequest, buffer_collection_info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnAllocateSingleBufferDoneRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnAllocateSingleBufferDoneRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnAllocateSingleBufferDoneRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnAllocateSingleBufferDoneRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnAllocateSingleBufferDoneRequest, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionEvents::OnAllocateSingleBufferDoneRequest, buffer_info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferUsage> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::BufferUsage>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferUsage, none) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferUsage, cpu) == 4);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferUsage, vulkan) == 8);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferUsage, display) == 12);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferUsage, video) == 16);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferUsage) == ::llcpp::fuchsia::sysmem::BufferUsage::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollectionConstraints> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::sysmem::BufferCollectionConstraints>);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, usage) == 0);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, min_buffer_count_for_camping) == 20);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, min_buffer_count_for_dedicated_slack) == 24);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, min_buffer_count_for_shared_slack) == 28);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, min_buffer_count) == 32);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, max_buffer_count) == 36);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, has_buffer_memory_constraints) == 40);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, buffer_memory_constraints) == 48);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, image_format_constraints_count) == 328);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints, image_format_constraints) == 336);
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollectionConstraints) == ::llcpp::fuchsia::sysmem::BufferCollectionConstraints::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::SetEventSinkRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::SetEventSinkRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::SetEventSinkRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::SetEventSinkRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::SetEventSinkRequest, events) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::SetConstraintsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::SetConstraintsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::SetConstraintsRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::SetConstraintsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::SetConstraintsRequest, has_constraints) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::SetConstraintsRequest, constraints) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::WaitForBuffersAllocatedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::WaitForBuffersAllocatedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::WaitForBuffersAllocatedResponse)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::WaitForBuffersAllocatedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::WaitForBuffersAllocatedResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::WaitForBuffersAllocatedResponse, buffer_collection_info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::CheckBuffersAllocatedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::CheckBuffersAllocatedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::CheckBuffersAllocatedResponse)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::CheckBuffersAllocatedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::CheckBuffersAllocatedResponse, status) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::CloseSingleBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::CloseSingleBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::CloseSingleBufferRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::CloseSingleBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::CloseSingleBufferRequest, buffer_index) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::AllocateSingleBufferRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::AllocateSingleBufferRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::AllocateSingleBufferRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::AllocateSingleBufferRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::AllocateSingleBufferRequest, buffer_index) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedRequest, buffer_index) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedResponse)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedResponse, status) == 16);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::WaitForSingleBufferAllocatedResponse, buffer_info) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::sysmem::BufferCollection::CheckSingleBufferAllocatedRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::sysmem::BufferCollection::CheckSingleBufferAllocatedRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::sysmem::BufferCollection::CheckSingleBufferAllocatedRequest)
+ == ::llcpp::fuchsia::sysmem::BufferCollection::CheckSingleBufferAllocatedRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::sysmem::BufferCollection::CheckSingleBufferAllocatedRequest, buffer_index) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-tee-manager/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-tee-manager/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..2adaec5
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-tee-manager/gen/llcpp/fidl.cc
@@ -0,0 +1,137 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/tee/manager/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace tee {
+namespace manager {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kProvider_RequestPersistentStorage_Ordinal = 0x7583eb000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kProvider_RequestPersistentStorage_GenOrdinal = 0x3ef6bac9b6490a0dlu;
+extern "C" const fidl_type_t v1_fuchsia_tee_manager_ProviderRequestPersistentStorageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_manager_ProviderRequestPersistentStorageResponseTable;
+
+} // namespace
+
+Provider::ResultOf::RequestPersistentStorage_Impl::RequestPersistentStorage_Impl(::zx::unowned_channel _client_end, ::zx::channel dir) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<RequestPersistentStorageRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, RequestPersistentStorageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RequestPersistentStorageRequest*>(_write_bytes);
+ _request.dir = std::move(dir);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(RequestPersistentStorageRequest));
+ ::fidl::DecodedMessage<RequestPersistentStorageRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ Provider::InPlace::RequestPersistentStorage(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Provider::ResultOf::RequestPersistentStorage Provider::SyncClient::RequestPersistentStorage(::zx::channel dir) {
+ return ResultOf::RequestPersistentStorage(::zx::unowned_channel(this->channel_), std::move(dir));
+}
+
+Provider::ResultOf::RequestPersistentStorage Provider::Call::RequestPersistentStorage(::zx::unowned_channel _client_end, ::zx::channel dir) {
+ return ResultOf::RequestPersistentStorage(std::move(_client_end), std::move(dir));
+}
+
+
+Provider::UnownedResultOf::RequestPersistentStorage_Impl::RequestPersistentStorage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel dir) {
+ if (_request_buffer.capacity() < RequestPersistentStorageRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ memset(_request_buffer.data(), 0, RequestPersistentStorageRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<RequestPersistentStorageRequest*>(_request_buffer.data());
+ _request.dir = std::move(dir);
+ _request_buffer.set_actual(sizeof(RequestPersistentStorageRequest));
+ ::fidl::DecodedMessage<RequestPersistentStorageRequest> _decoded_request(std::move(_request_buffer));
+ Super::operator=(
+ Provider::InPlace::RequestPersistentStorage(std::move(_client_end), std::move(_decoded_request)));
+}
+
+Provider::UnownedResultOf::RequestPersistentStorage Provider::SyncClient::RequestPersistentStorage(::fidl::BytePart _request_buffer, ::zx::channel dir) {
+ return UnownedResultOf::RequestPersistentStorage(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(dir));
+}
+
+Provider::UnownedResultOf::RequestPersistentStorage Provider::Call::RequestPersistentStorage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel dir) {
+ return UnownedResultOf::RequestPersistentStorage(std::move(_client_end), std::move(_request_buffer), std::move(dir));
+}
+
+::fidl::internal::StatusAndError Provider::InPlace::RequestPersistentStorage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RequestPersistentStorageRequest> params) {
+ Provider::SetTransactionHeaderFor::RequestPersistentStorageRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+bool Provider::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kProvider_RequestPersistentStorage_Ordinal:
+ case kProvider_RequestPersistentStorage_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<RequestPersistentStorageRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->RequestPersistentStorage(std::move(message->dir),
+ Interface::RequestPersistentStorageCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Provider::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+
+void Provider::SetTransactionHeaderFor::RequestPersistentStorageRequest(const ::fidl::DecodedMessage<Provider::RequestPersistentStorageRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kProvider_RequestPersistentStorage_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace manager
+} // namespace tee
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-tee-manager/gen/llcpp/include/fuchsia/tee/manager/llcpp/fidl.h b/zircon/system/fidl/fuchsia-tee-manager/gen/llcpp/include/fuchsia/tee/manager/llcpp/fidl.h
new file mode 100644
index 0000000..14ec156
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-tee-manager/gen/llcpp/include/fuchsia/tee/manager/llcpp/fidl.h
@@ -0,0 +1,200 @@
+// 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 <zircon/fidl.h>
+
+#include <fuchsia/io/llcpp/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace tee {
+namespace manager {
+
+class Provider;
+
+extern "C" const fidl_type_t v1_fuchsia_tee_manager_ProviderRequestPersistentStorageRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_manager_ProviderRequestPersistentStorageResponseTable;
+
+// Provider provides service access and support to the TEE driver
+// for things like persistent storage, since the TEE may make upward RPC-like
+// requests to the REE.
+class Provider final {
+ Provider() = delete;
+ public:
+
+ struct RequestPersistentStorageRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::zx::channel dir;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_manager_ProviderRequestPersistentStorageRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class RequestPersistentStorage_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ RequestPersistentStorage_Impl(::zx::unowned_channel _client_end, ::zx::channel dir);
+ ~RequestPersistentStorage_Impl() = default;
+ RequestPersistentStorage_Impl(RequestPersistentStorage_Impl&& other) = default;
+ RequestPersistentStorage_Impl& operator=(RequestPersistentStorage_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using RequestPersistentStorage = RequestPersistentStorage_Impl;
+ };
+
+ // 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:
+ class RequestPersistentStorage_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ RequestPersistentStorage_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel dir);
+ ~RequestPersistentStorage_Impl() = default;
+ RequestPersistentStorage_Impl(RequestPersistentStorage_Impl&& other) = default;
+ RequestPersistentStorage_Impl& operator=(RequestPersistentStorage_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using RequestPersistentStorage = RequestPersistentStorage_Impl;
+ };
+
+ 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 24 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::RequestPersistentStorage RequestPersistentStorage(::zx::channel dir);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::RequestPersistentStorage RequestPersistentStorage(::fidl::BytePart _request_buffer, ::zx::channel dir);
+
+ 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 24 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::RequestPersistentStorage RequestPersistentStorage(::zx::unowned_channel _client_end, ::zx::channel dir);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::RequestPersistentStorage RequestPersistentStorage(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::zx::channel dir);
+
+ };
+
+ // 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::internal::StatusAndError RequestPersistentStorage(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<RequestPersistentStorageRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Provider;
+ using _Base = ::fidl::CompleterBase;
+
+ using RequestPersistentStorageCompleter = ::fidl::Completer<>;
+
+ virtual void RequestPersistentStorage(::zx::channel dir, RequestPersistentStorageCompleter::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 RequestPersistentStorageRequest(const ::fidl::DecodedMessage<Provider::RequestPersistentStorageRequest>& _msg);
+ };
+};
+
+} // namespace manager
+} // namespace tee
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::manager::Provider::RequestPersistentStorageRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::tee::manager::Provider::RequestPersistentStorageRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::tee::manager::Provider::RequestPersistentStorageRequest)
+ == ::llcpp::fuchsia::tee::manager::Provider::RequestPersistentStorageRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::tee::manager::Provider::RequestPersistentStorageRequest, dir) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/fidl/fuchsia-tee/gen/llcpp/fidl.cc b/zircon/system/fidl/fuchsia-tee/gen/llcpp/fidl.cc
new file mode 100644
index 0000000..4daa35f
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-tee/gen/llcpp/fidl.cc
@@ -0,0 +1,757 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fuchsia/tee/llcpp/fidl.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace tee {
+
+::llcpp::fuchsia::tee::OsRevision::Builder OsRevision::Build() {
+ return OsRevision::Builder();
+}
+
+auto ::llcpp::fuchsia::tee::OsRevision::Builder::set_major(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::OsRevision::Builder::set_minor(uint32_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::tee::OsInfo::Builder OsInfo::Build() {
+ return OsInfo::Builder();
+}
+
+auto ::llcpp::fuchsia::tee::OsInfo::Builder::set_uuid(::llcpp::fuchsia::tee::Uuid* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::OsInfo::Builder::set_revision(::llcpp::fuchsia::tee::OsRevision* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::OsInfo::Builder::set_is_global_platform_compliant(bool* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::tee::Value::Builder Value::Build() {
+ return Value::Builder();
+}
+
+auto ::llcpp::fuchsia::tee::Value::Builder::set_direction(::llcpp::fuchsia::tee::Direction* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::Value::Builder::set_a(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::Value::Builder::set_b(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::Value::Builder::set_c(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+
+::llcpp::fuchsia::tee::Buffer::Builder Buffer::Build() {
+ return Buffer::Builder();
+}
+
+auto ::llcpp::fuchsia::tee::Buffer::Builder::set_direction(::llcpp::fuchsia::tee::Direction* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::Buffer::Builder::set_vmo(::zx::vmo* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::Buffer::Builder::set_offset(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::Buffer::Builder::set_size(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[4 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 4) {
+ max_ordinal_ = 4;
+ }
+ return std::move(*this);
+}
+auto ::llcpp::fuchsia::tee::Parameter::which() const -> Tag {
+ ZX_ASSERT(!has_invalid_tag());
+ switch (ordinal()) {
+ case Ordinal::kNone:
+ case Ordinal::kBuffer:
+ case Ordinal::kValue:
+ return static_cast<Tag>(ordinal());
+ default:
+ return Tag::kUnknown;
+ }
+}
+
+void ::llcpp::fuchsia::tee::Parameter::SizeAndOffsetAssertionHelper() {
+ static_assert(sizeof(Parameter) == sizeof(fidl_xunion_t));
+ static_assert(offsetof(Parameter, ordinal_) == offsetof(fidl_xunion_t, tag));
+ static_assert(offsetof(Parameter, envelope_) == offsetof(fidl_xunion_t, envelope));
+}
+
+::llcpp::fuchsia::tee::OpResult::Builder OpResult::Build() {
+ return OpResult::Builder();
+}
+
+auto ::llcpp::fuchsia::tee::OpResult::Builder::set_return_code(uint64_t* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[1 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 1) {
+ max_ordinal_ = 1;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::OpResult::Builder::set_return_origin(::llcpp::fuchsia::tee::ReturnOrigin* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[2 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 2) {
+ max_ordinal_ = 2;
+ }
+ return std::move(*this);
+}
+
+auto ::llcpp::fuchsia::tee::OpResult::Builder::set_parameter_set(::fidl::VectorView<::llcpp::fuchsia::tee::Parameter>* elem) -> Builder&& {
+ ZX_ASSERT(elem);
+ envelopes_[3 - 1].data = static_cast<void*>(elem);
+ if (max_ordinal_ < 3) {
+ max_ordinal_ = 3;
+ }
+ return std::move(*this);
+}
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetOsInfo_Ordinal = 0x6d1d83f300000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_GetOsInfo_GenOrdinal = 0x9b65a9e69ce2ff0lu;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceGetOsInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceGetOsInfoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_OpenSession_Ordinal = 0x3c7d253d00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_OpenSession_GenOrdinal = 0x611e642d24d5d425lu;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceOpenSessionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceOpenSessionResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_InvokeCommand_Ordinal = 0x202511b100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_InvokeCommand_GenOrdinal = 0x6cba9f107e725868lu;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceInvokeCommandRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceInvokeCommandResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDevice_CloseSession_Ordinal = 0x53bbaea700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDevice_CloseSession_GenOrdinal = 0x7c21cc4c0084d8aflu;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceCloseSessionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceCloseSessionResponseTable;
+
+} // namespace
+template <>
+Device::ResultOf::GetOsInfo_Impl<Device::GetOsInfoResponse>::GetOsInfo_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetOsInfoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, GetOsInfoRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(GetOsInfoRequest));
+ ::fidl::DecodedMessage<GetOsInfoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::GetOsInfo(std::move(_client_end), Super::response_buffer()));
+}
+
+Device::ResultOf::GetOsInfo Device::SyncClient::GetOsInfo() {
+ return ResultOf::GetOsInfo(::zx::unowned_channel(this->channel_));
+}
+
+Device::ResultOf::GetOsInfo Device::Call::GetOsInfo(::zx::unowned_channel _client_end) {
+ return ResultOf::GetOsInfo(std::move(_client_end));
+}
+
+template <>
+Device::UnownedResultOf::GetOsInfo_Impl<Device::GetOsInfoResponse>::GetOsInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(GetOsInfoRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, GetOsInfoRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(GetOsInfoRequest));
+ ::fidl::DecodedMessage<GetOsInfoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::GetOsInfo(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::GetOsInfo Device::SyncClient::GetOsInfo(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetOsInfo(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::GetOsInfo Device::Call::GetOsInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::GetOsInfo(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::GetOsInfoResponse> Device::InPlace::GetOsInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(GetOsInfoRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<GetOsInfoRequest> params(std::move(_request_buffer));
+ Device::SetTransactionHeaderFor::GetOsInfoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetOsInfoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<GetOsInfoRequest, GetOsInfoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::GetOsInfoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::OpenSession_Impl<Device::OpenSessionResponse>::OpenSession_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenSessionRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ OpenSessionRequest _request = {};
+ _request.trusted_app = std::move(trusted_app);
+ _request.parameter_set = std::move(parameter_set);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenSessionRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::OpenSession(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::OpenSession Device::SyncClient::OpenSession(::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set) {
+ return ResultOf::OpenSession(::zx::unowned_channel(this->channel_), std::move(trusted_app), std::move(parameter_set));
+}
+
+Device::ResultOf::OpenSession Device::Call::OpenSession(::zx::unowned_channel _client_end, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set) {
+ return ResultOf::OpenSession(std::move(_client_end), std::move(trusted_app), std::move(parameter_set));
+}
+
+template <>
+Device::UnownedResultOf::OpenSession_Impl<Device::OpenSessionResponse>::OpenSession_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < OpenSessionRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<OpenSessionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ OpenSessionRequest _request = {};
+ _request.trusted_app = std::move(trusted_app);
+ _request.parameter_set = std::move(parameter_set);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OpenSessionRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::OpenSession(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::OpenSession Device::SyncClient::OpenSession(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenSession(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(trusted_app), std::move(parameter_set), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::OpenSession Device::Call::OpenSession(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::OpenSession(std::move(_client_end), std::move(_request_buffer), std::move(trusted_app), std::move(parameter_set), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::OpenSessionResponse> Device::InPlace::OpenSession(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenSessionRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::OpenSessionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::OpenSessionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<OpenSessionRequest, OpenSessionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::OpenSessionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::InvokeCommand_Impl<Device::InvokeCommandResponse>::InvokeCommand_Impl(::zx::unowned_channel _client_end, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InvokeCommandRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ InvokeCommandRequest _request = {};
+ _request.session_id = std::move(session_id);
+ _request.command_id = std::move(command_id);
+ _request.parameter_set = std::move(parameter_set);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<InvokeCommandRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::InvokeCommand(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::InvokeCommand Device::SyncClient::InvokeCommand(uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set) {
+ return ResultOf::InvokeCommand(::zx::unowned_channel(this->channel_), std::move(session_id), std::move(command_id), std::move(parameter_set));
+}
+
+Device::ResultOf::InvokeCommand Device::Call::InvokeCommand(::zx::unowned_channel _client_end, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set) {
+ return ResultOf::InvokeCommand(std::move(_client_end), std::move(session_id), std::move(command_id), std::move(parameter_set));
+}
+
+template <>
+Device::UnownedResultOf::InvokeCommand_Impl<Device::InvokeCommandResponse>::InvokeCommand_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < InvokeCommandRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<InvokeCommandResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ InvokeCommandRequest _request = {};
+ _request.session_id = std::move(session_id);
+ _request.command_id = std::move(command_id);
+ _request.parameter_set = std::move(parameter_set);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<InvokeCommandRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Device::InPlace::InvokeCommand(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::InvokeCommand Device::SyncClient::InvokeCommand(::fidl::BytePart _request_buffer, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::InvokeCommand(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(session_id), std::move(command_id), std::move(parameter_set), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::InvokeCommand Device::Call::InvokeCommand(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::InvokeCommand(std::move(_client_end), std::move(_request_buffer), std::move(session_id), std::move(command_id), std::move(parameter_set), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::InvokeCommandResponse> Device::InPlace::InvokeCommand(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<InvokeCommandRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::InvokeCommandRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::InvokeCommandResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<InvokeCommandRequest, InvokeCommandResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::InvokeCommandResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Device::ResultOf::CloseSession_Impl<Device::CloseSessionResponse>::CloseSession_Impl(::zx::unowned_channel _client_end, uint32_t session_id) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseSessionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseSessionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloseSessionRequest*>(_write_bytes);
+ _request.session_id = std::move(session_id);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseSessionRequest));
+ ::fidl::DecodedMessage<CloseSessionRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Device::InPlace::CloseSession(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Device::ResultOf::CloseSession Device::SyncClient::CloseSession(uint32_t session_id) {
+ return ResultOf::CloseSession(::zx::unowned_channel(this->channel_), std::move(session_id));
+}
+
+Device::ResultOf::CloseSession Device::Call::CloseSession(::zx::unowned_channel _client_end, uint32_t session_id) {
+ return ResultOf::CloseSession(std::move(_client_end), std::move(session_id));
+}
+
+template <>
+Device::UnownedResultOf::CloseSession_Impl<Device::CloseSessionResponse>::CloseSession_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t session_id, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CloseSessionRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CloseSessionResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, CloseSessionRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<CloseSessionRequest*>(_request_buffer.data());
+ _request.session_id = std::move(session_id);
+ _request_buffer.set_actual(sizeof(CloseSessionRequest));
+ ::fidl::DecodedMessage<CloseSessionRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Device::InPlace::CloseSession(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Device::UnownedResultOf::CloseSession Device::SyncClient::CloseSession(::fidl::BytePart _request_buffer, uint32_t session_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CloseSession(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(session_id), std::move(_response_buffer));
+}
+
+Device::UnownedResultOf::CloseSession Device::Call::CloseSession(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t session_id, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CloseSession(std::move(_client_end), std::move(_request_buffer), std::move(session_id), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Device::CloseSessionResponse> Device::InPlace::CloseSession(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloseSessionRequest> params, ::fidl::BytePart response_buffer) {
+ Device::SetTransactionHeaderFor::CloseSessionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::CloseSessionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseSessionRequest, CloseSessionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Device::CloseSessionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Device::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDevice_GetOsInfo_Ordinal:
+ case kDevice_GetOsInfo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<GetOsInfoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->GetOsInfo(
+ Interface::GetOsInfoCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_OpenSession_Ordinal:
+ case kDevice_OpenSession_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OpenSessionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OpenSession(std::move(message->trusted_app), std::move(message->parameter_set),
+ Interface::OpenSessionCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_InvokeCommand_Ordinal:
+ case kDevice_InvokeCommand_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<InvokeCommandRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->InvokeCommand(std::move(message->session_id), std::move(message->command_id), std::move(message->parameter_set),
+ Interface::InvokeCommandCompleter::Sync(txn));
+ return true;
+ }
+ case kDevice_CloseSession_Ordinal:
+ case kDevice_CloseSession_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseSessionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CloseSession(std::move(message->session_id),
+ Interface::CloseSessionCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Device::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Device::Interface::GetOsInfoCompleterBase::Reply(::llcpp::fuchsia::tee::OsInfo info) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<GetOsInfoResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ GetOsInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetOsInfoResponse(
+ ::fidl::DecodedMessage<GetOsInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetOsInfoResponse::PrimarySize,
+ GetOsInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetOsInfoCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::tee::OsInfo info) {
+ if (_buffer.capacity() < GetOsInfoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ GetOsInfoResponse _response = {};
+ Device::SetTransactionHeaderFor::GetOsInfoResponse(
+ ::fidl::DecodedMessage<GetOsInfoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ GetOsInfoResponse::PrimarySize,
+ GetOsInfoResponse::PrimarySize)));
+ _response.info = std::move(info);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::GetOsInfoCompleterBase::Reply(::fidl::DecodedMessage<GetOsInfoResponse> params) {
+ Device::SetTransactionHeaderFor::GetOsInfoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::OpenSessionCompleterBase::Reply(uint32_t session_id, ::llcpp::fuchsia::tee::OpResult op_result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OpenSessionResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OpenSessionResponse _response = {};
+ Device::SetTransactionHeaderFor::OpenSessionResponse(
+ ::fidl::DecodedMessage<OpenSessionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenSessionResponse::PrimarySize,
+ OpenSessionResponse::PrimarySize)));
+ _response.session_id = std::move(session_id);
+ _response.op_result = std::move(op_result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::OpenSessionCompleterBase::Reply(::fidl::BytePart _buffer, uint32_t session_id, ::llcpp::fuchsia::tee::OpResult op_result) {
+ if (_buffer.capacity() < OpenSessionResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ OpenSessionResponse _response = {};
+ Device::SetTransactionHeaderFor::OpenSessionResponse(
+ ::fidl::DecodedMessage<OpenSessionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OpenSessionResponse::PrimarySize,
+ OpenSessionResponse::PrimarySize)));
+ _response.session_id = std::move(session_id);
+ _response.op_result = std::move(op_result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::OpenSessionCompleterBase::Reply(::fidl::DecodedMessage<OpenSessionResponse> params) {
+ Device::SetTransactionHeaderFor::OpenSessionResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::InvokeCommandCompleterBase::Reply(::llcpp::fuchsia::tee::OpResult op_result) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<InvokeCommandResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ InvokeCommandResponse _response = {};
+ Device::SetTransactionHeaderFor::InvokeCommandResponse(
+ ::fidl::DecodedMessage<InvokeCommandResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InvokeCommandResponse::PrimarySize,
+ InvokeCommandResponse::PrimarySize)));
+ _response.op_result = std::move(op_result);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::InvokeCommandCompleterBase::Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::tee::OpResult op_result) {
+ if (_buffer.capacity() < InvokeCommandResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ InvokeCommandResponse _response = {};
+ Device::SetTransactionHeaderFor::InvokeCommandResponse(
+ ::fidl::DecodedMessage<InvokeCommandResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ InvokeCommandResponse::PrimarySize,
+ InvokeCommandResponse::PrimarySize)));
+ _response.op_result = std::move(op_result);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Device::Interface::InvokeCommandCompleterBase::Reply(::fidl::DecodedMessage<InvokeCommandResponse> params) {
+ Device::SetTransactionHeaderFor::InvokeCommandResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Device::Interface::CloseSessionCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseSessionResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseSessionResponse*>(_write_bytes);
+ Device::SetTransactionHeaderFor::CloseSessionResponse(
+ ::fidl::DecodedMessage<CloseSessionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseSessionResponse::PrimarySize,
+ CloseSessionResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseSessionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseSessionResponse>(std::move(_response_bytes)));
+}
+
+
+
+void Device::SetTransactionHeaderFor::GetOsInfoRequest(const ::fidl::DecodedMessage<Device::GetOsInfoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetOsInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::GetOsInfoResponse(const ::fidl::DecodedMessage<Device::GetOsInfoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_GetOsInfo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::OpenSessionRequest(const ::fidl::DecodedMessage<Device::OpenSessionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_OpenSession_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::OpenSessionResponse(const ::fidl::DecodedMessage<Device::OpenSessionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_OpenSession_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::InvokeCommandRequest(const ::fidl::DecodedMessage<Device::InvokeCommandRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_InvokeCommand_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::InvokeCommandResponse(const ::fidl::DecodedMessage<Device::InvokeCommandResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_InvokeCommand_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Device::SetTransactionHeaderFor::CloseSessionRequest(const ::fidl::DecodedMessage<Device::CloseSessionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_CloseSession_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Device::SetTransactionHeaderFor::CloseSessionResponse(const ::fidl::DecodedMessage<Device::CloseSessionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDevice_CloseSession_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace tee
+} // namespace fuchsia
+} // namespace llcpp
diff --git a/zircon/system/fidl/fuchsia-tee/gen/llcpp/include/fuchsia/tee/llcpp/fidl.h b/zircon/system/fidl/fuchsia-tee/gen/llcpp/include/fuchsia/tee/llcpp/fidl.h
new file mode 100644
index 0000000..b04e24f4
--- /dev/null
+++ b/zircon/system/fidl/fuchsia-tee/gen/llcpp/include/fuchsia/tee/llcpp/fidl.h
@@ -0,0 +1,1257 @@
+// 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/vmo.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fuchsia {
+namespace tee {
+
+struct Uuid;
+enum class ReturnOrigin : uint32_t {
+ COMMUNICATION = 0u,
+ TRUSTED_OS = 1u,
+ TRUSTED_APPLICATION = 2u,
+};
+
+
+struct OsRevision;
+struct OsInfo;
+struct None;
+enum class Direction : uint32_t {
+ INPUT = 0u,
+ OUTPUT = 1u,
+ INOUT = 2u,
+};
+
+
+struct Value;
+struct Buffer;
+struct Parameter;
+struct OpResult;
+class Device;
+
+extern "C" const fidl_type_t v1_fuchsia_tee_OsRevisionTable;
+
+struct OsRevision final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const uint32_t& major() const {
+ ZX_ASSERT(has_major());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ uint32_t& major() {
+ ZX_ASSERT(has_major());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_major() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ const uint32_t& minor() const {
+ ZX_ASSERT(has_minor());
+ return *reinterpret_cast<const uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ uint32_t& minor() {
+ ZX_ASSERT(has_minor());
+ return *reinterpret_cast<uint32_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_minor() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ OsRevision() = default;
+ ~OsRevision() = default;
+ OsRevision(OsRevision&& other) noexcept = default;
+ OsRevision& operator=(OsRevision&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_OsRevisionTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 48;
+ static constexpr bool HasPointer = true;
+
+ private:
+ OsRevision(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class OsRevision::Builder {
+ public:
+ OsRevision view() { return OsRevision(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_major(uint32_t* elem);
+
+ Builder&& set_minor(uint32_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder OsRevision::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 2> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_tee_OsInfoTable;
+
+struct OsInfo final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const ::llcpp::fuchsia::tee::Uuid& uuid() const {
+ ZX_ASSERT(has_uuid());
+ return *reinterpret_cast<const ::llcpp::fuchsia::tee::Uuid*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::tee::Uuid& uuid() {
+ ZX_ASSERT(has_uuid());
+ return *reinterpret_cast<::llcpp::fuchsia::tee::Uuid*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_uuid() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ const ::llcpp::fuchsia::tee::OsRevision& revision() const {
+ ZX_ASSERT(has_revision());
+ return *reinterpret_cast<const ::llcpp::fuchsia::tee::OsRevision*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::tee::OsRevision& revision() {
+ ZX_ASSERT(has_revision());
+ return *reinterpret_cast<::llcpp::fuchsia::tee::OsRevision*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_revision() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ const bool& is_global_platform_compliant() const {
+ ZX_ASSERT(has_is_global_platform_compliant());
+ return *reinterpret_cast<const bool*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool& is_global_platform_compliant() {
+ ZX_ASSERT(has_is_global_platform_compliant());
+ return *reinterpret_cast<bool*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_is_global_platform_compliant() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ OsInfo() = default;
+ ~OsInfo() = default;
+ OsInfo(OsInfo&& other) noexcept = default;
+ OsInfo& operator=(OsInfo&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_OsInfoTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 136;
+ static constexpr bool HasPointer = true;
+
+ private:
+ OsInfo(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class OsInfo::Builder {
+ public:
+ OsInfo view() { return OsInfo(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_uuid(::llcpp::fuchsia::tee::Uuid* elem);
+
+ Builder&& set_revision(::llcpp::fuchsia::tee::OsRevision* elem);
+
+ Builder&& set_is_global_platform_compliant(bool* elem);
+
+ private:
+ Builder() = default;
+ friend Builder OsInfo::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 3> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_tee_ValueTable;
+
+// Represents a direct value parameter.
+struct Value final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const ::llcpp::fuchsia::tee::Direction& direction() const {
+ ZX_ASSERT(has_direction());
+ return *reinterpret_cast<const ::llcpp::fuchsia::tee::Direction*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::tee::Direction& direction() {
+ ZX_ASSERT(has_direction());
+ return *reinterpret_cast<::llcpp::fuchsia::tee::Direction*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_direction() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // This value is optional. If not set, a zero value is sent in its place if it is required by
+ // the calling convention.
+ const uint64_t& a() const {
+ ZX_ASSERT(has_a());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ uint64_t& a() {
+ ZX_ASSERT(has_a());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_a() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ // This value is optional. If not set, a zero value is sent in its place if it is required by
+ // the calling convention.
+ const uint64_t& b() const {
+ ZX_ASSERT(has_b());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ uint64_t& b() {
+ ZX_ASSERT(has_b());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_b() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ // This value is optional. If not set, a zero value is sent in its place if it is required by
+ // the calling convention.
+ const uint64_t& c() const {
+ ZX_ASSERT(has_c());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ uint64_t& c() {
+ ZX_ASSERT(has_c());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_c() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ Value() = default;
+ ~Value() = default;
+ Value(Value&& other) noexcept = default;
+ Value& operator=(Value&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_ValueTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 96;
+ static constexpr bool HasPointer = true;
+
+ private:
+ Value(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class Value::Builder {
+ public:
+ Value view() { return Value(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_direction(::llcpp::fuchsia::tee::Direction* elem);
+
+ // This value is optional. If not set, a zero value is sent in its place if it is required by
+ // the calling convention.
+ Builder&& set_a(uint64_t* elem);
+
+ // This value is optional. If not set, a zero value is sent in its place if it is required by
+ // the calling convention.
+ Builder&& set_b(uint64_t* elem);
+
+ // This value is optional. If not set, a zero value is sent in its place if it is required by
+ // the calling convention.
+ Builder&& set_c(uint64_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder Value::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 4> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_tee_BufferTable;
+
+// Represents a buffer parameter.
+struct Buffer final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const ::llcpp::fuchsia::tee::Direction& direction() const {
+ ZX_ASSERT(has_direction());
+ return *reinterpret_cast<const ::llcpp::fuchsia::tee::Direction*>(EnvelopesView::at(1 - 1).data);
+ }
+ ::llcpp::fuchsia::tee::Direction& direction() {
+ ZX_ASSERT(has_direction());
+ return *reinterpret_cast<::llcpp::fuchsia::tee::Direction*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_direction() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ // The VMO is allowed to be not present for situations where the TEE allows for buffer size
+ // checks.
+ //
+ // For example, if the operation to be performed needs an output buffer, but the user cannot
+ // calculate how large that output buffer should be, they can attempt the operation without
+ // a vmo and the Trusted Application will populate the size field so that the operation can
+ // be performed again with an appropriately sized buffer.
+ const ::zx::vmo& vmo() const {
+ ZX_ASSERT(has_vmo());
+ return *reinterpret_cast<const ::zx::vmo*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::zx::vmo& vmo() {
+ ZX_ASSERT(has_vmo());
+ return *reinterpret_cast<::zx::vmo*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_vmo() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ const uint64_t& offset() const {
+ ZX_ASSERT(has_offset());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ uint64_t& offset() {
+ ZX_ASSERT(has_offset());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_offset() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ const uint64_t& size() const {
+ ZX_ASSERT(has_size());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ uint64_t& size() {
+ ZX_ASSERT(has_size());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(4 - 1).data);
+ }
+ bool has_size() const {
+ return EnvelopesView::count() >= 4 && EnvelopesView::at(4 - 1).data != nullptr;
+ }
+
+ Buffer() = default;
+ ~Buffer() = default;
+ Buffer(Buffer&& other) noexcept = default;
+ Buffer& operator=(Buffer&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_BufferTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 96;
+ static constexpr bool HasPointer = true;
+
+ private:
+ Buffer(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class Buffer::Builder {
+ public:
+ Buffer view() { return Buffer(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_direction(::llcpp::fuchsia::tee::Direction* elem);
+
+ // The VMO is allowed to be not present for situations where the TEE allows for buffer size
+ // checks.
+ //
+ // For example, if the operation to be performed needs an output buffer, but the user cannot
+ // calculate how large that output buffer should be, they can attempt the operation without
+ // a vmo and the Trusted Application will populate the size field so that the operation can
+ // be performed again with an appropriately sized buffer.
+ Builder&& set_vmo(::zx::vmo* elem);
+
+ Builder&& set_offset(uint64_t* elem);
+
+ Builder&& set_size(uint64_t* elem);
+
+ private:
+ Builder() = default;
+ friend Builder Buffer::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 4> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_tee_ParameterTable;
+
+struct Parameter {
+ Parameter() : ordinal_(Ordinal::Invalid), envelope_{} {}
+
+ enum class Tag : fidl_xunion_tag_t {
+ kNone = 1, // 0x1
+ kBuffer = 2, // 0x2
+ kValue = 3, // 0x3
+ kUnknown = ::std::numeric_limits<::fidl_union_tag_t>::max(),
+ };
+
+ bool has_invalid_tag() const { return ordinal_ == Ordinal::Invalid; }
+
+ bool is_none() const { return ordinal() == Ordinal::kNone; }
+
+ static Parameter WithNone(::llcpp::fuchsia::tee::None* val) {
+ Parameter result;
+ result.set_none(val);
+ return result;
+ }
+
+ void set_none(::llcpp::fuchsia::tee::None* elem) {
+ ordinal_ = Ordinal::kNone;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::tee::None& mutable_none() {
+ ZX_ASSERT(ordinal() == Ordinal::kNone);
+ return *static_cast<::llcpp::fuchsia::tee::None*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::tee::None& none() const {
+ ZX_ASSERT(ordinal() == Ordinal::kNone);
+ return *static_cast<::llcpp::fuchsia::tee::None*>(envelope_.data);
+ }
+
+ bool is_buffer() const { return ordinal() == Ordinal::kBuffer; }
+
+ static Parameter WithBuffer(::llcpp::fuchsia::tee::Buffer* val) {
+ Parameter result;
+ result.set_buffer(val);
+ return result;
+ }
+
+ void set_buffer(::llcpp::fuchsia::tee::Buffer* elem) {
+ ordinal_ = Ordinal::kBuffer;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::tee::Buffer& mutable_buffer() {
+ ZX_ASSERT(ordinal() == Ordinal::kBuffer);
+ return *static_cast<::llcpp::fuchsia::tee::Buffer*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::tee::Buffer& buffer() const {
+ ZX_ASSERT(ordinal() == Ordinal::kBuffer);
+ return *static_cast<::llcpp::fuchsia::tee::Buffer*>(envelope_.data);
+ }
+
+ bool is_value() const { return ordinal() == Ordinal::kValue; }
+
+ static Parameter WithValue(::llcpp::fuchsia::tee::Value* val) {
+ Parameter result;
+ result.set_value(val);
+ return result;
+ }
+
+ void set_value(::llcpp::fuchsia::tee::Value* elem) {
+ ordinal_ = Ordinal::kValue;
+ envelope_.data = static_cast<void*>(elem);
+ }
+
+ ::llcpp::fuchsia::tee::Value& mutable_value() {
+ ZX_ASSERT(ordinal() == Ordinal::kValue);
+ return *static_cast<::llcpp::fuchsia::tee::Value*>(envelope_.data);
+ }
+ const ::llcpp::fuchsia::tee::Value& value() const {
+ ZX_ASSERT(ordinal() == Ordinal::kValue);
+ return *static_cast<::llcpp::fuchsia::tee::Value*>(envelope_.data);
+ }
+ void* unknownData() const {
+ ZX_ASSERT(which() == Tag::kUnknown);
+ return envelope_.data;
+ }
+ Tag which() const;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_ParameterTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 24;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 112;
+ static constexpr bool HasPointer = true;
+
+ private:
+ enum class Ordinal : fidl_xunion_tag_t {
+ Invalid = 0,
+ kNone = 1, // 0x1
+ kBuffer = 2, // 0x2
+ kValue = 3, // 0x3
+ };
+
+ Ordinal ordinal() const {
+ switch (static_cast<fidl_xunion_tag_t>(ordinal_)) {
+ case 1:
+ case 614881370:
+ return Ordinal::kNone;
+ case 2:
+ case 526330047:
+ return Ordinal::kBuffer;
+ case 3:
+ case 483243862:
+ return Ordinal::kValue;
+ }
+ return ordinal_;
+ }
+
+ static void SizeAndOffsetAssertionHelper();
+ Ordinal ordinal_;
+ FIDL_ALIGNDECL
+ fidl_envelope_t envelope_;
+};
+
+extern "C" const fidl_type_t v1_fuchsia_tee_OpResultTable;
+
+// The result of an operation will include a return code, the origin of the result, and the return
+// of the parameter set. The returned parameter set will be a copy of the input parameter set, but
+// with the INOUT and OUTPUT parameters updated. If the parameter is a Buffer, it will update the
+// Buffer.size to the number of bytes written.
+struct OpResult final : private ::fidl::VectorView<fidl_envelope_t> {
+ using EnvelopesView = ::fidl::VectorView<fidl_envelope_t>;
+ public:
+ // Returns whether no field is set.
+ bool IsEmpty() const { return EnvelopesView::empty(); }
+
+ const uint64_t& return_code() const {
+ ZX_ASSERT(has_return_code());
+ return *reinterpret_cast<const uint64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ uint64_t& return_code() {
+ ZX_ASSERT(has_return_code());
+ return *reinterpret_cast<uint64_t*>(EnvelopesView::at(1 - 1).data);
+ }
+ bool has_return_code() const {
+ return EnvelopesView::count() >= 1 && EnvelopesView::at(1 - 1).data != nullptr;
+ }
+
+ const ::llcpp::fuchsia::tee::ReturnOrigin& return_origin() const {
+ ZX_ASSERT(has_return_origin());
+ return *reinterpret_cast<const ::llcpp::fuchsia::tee::ReturnOrigin*>(EnvelopesView::at(2 - 1).data);
+ }
+ ::llcpp::fuchsia::tee::ReturnOrigin& return_origin() {
+ ZX_ASSERT(has_return_origin());
+ return *reinterpret_cast<::llcpp::fuchsia::tee::ReturnOrigin*>(EnvelopesView::at(2 - 1).data);
+ }
+ bool has_return_origin() const {
+ return EnvelopesView::count() >= 2 && EnvelopesView::at(2 - 1).data != nullptr;
+ }
+
+ const ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter>& parameter_set() const {
+ ZX_ASSERT(has_parameter_set());
+ return *reinterpret_cast<const ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter>*>(EnvelopesView::at(3 - 1).data);
+ }
+ ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter>& parameter_set() {
+ ZX_ASSERT(has_parameter_set());
+ return *reinterpret_cast<::fidl::VectorView<::llcpp::fuchsia::tee::Parameter>*>(EnvelopesView::at(3 - 1).data);
+ }
+ bool has_parameter_set() const {
+ return EnvelopesView::count() >= 3 && EnvelopesView::at(3 - 1).data != nullptr;
+ }
+
+ OpResult() = default;
+ ~OpResult() = default;
+ OpResult(OpResult&& other) noexcept = default;
+ OpResult& operator=(OpResult&& other) noexcept = default;
+
+ class Builder;
+ friend class Builder;
+ static Builder Build();
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_OpResultTable;
+ static constexpr uint32_t MaxNumHandles = 4;
+ static constexpr uint32_t PrimarySize = 16;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 624;
+ static constexpr bool HasPointer = true;
+
+ private:
+ OpResult(uint64_t max_ordinal, fidl_envelope_t* data) : EnvelopesView(data, max_ordinal) {}
+};
+
+class OpResult::Builder {
+ public:
+ OpResult view() { return OpResult(max_ordinal_, envelopes_.data_); }
+ ~Builder() = default;
+ Builder(Builder&& other) noexcept = default;
+ Builder& operator=(Builder&& other) noexcept = default;
+
+ Builder&& set_return_code(uint64_t* elem);
+
+ Builder&& set_return_origin(::llcpp::fuchsia::tee::ReturnOrigin* elem);
+
+ Builder&& set_parameter_set(::fidl::VectorView<::llcpp::fuchsia::tee::Parameter>* elem);
+
+ private:
+ Builder() = default;
+ friend Builder OpResult::Build();
+
+ uint64_t max_ordinal_ = 0;
+ ::fidl::Array<fidl_envelope_t, 3> envelopes_ = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_tee_UuidTable;
+
+// UUID identifiers are used to identify the TEE Operating System and individual Trusted
+// Applications. This structure matches the UUID type as defined by RFC4122.
+struct Uuid {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_UuidTable;
+ 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;
+
+ uint32_t time_low = {};
+
+ uint16_t time_mid = {};
+
+ uint16_t time_hi_and_version = {};
+
+ ::fidl::Array<uint8_t, 8> clock_seq_and_node = {};
+};
+
+extern "C" const fidl_type_t v1_fuchsia_tee_NoneTable;
+
+// An empty parameter type is used as a placeholder for elements in the parameter set that are not
+// used.
+struct None {
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_NoneTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 1;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ uint8_t __reserved = {};
+};
+
+constexpr uint32_t MAX_PARAMETERSET_COUNT = 4u;
+
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceGetOsInfoRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceGetOsInfoResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceOpenSessionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceOpenSessionResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceInvokeCommandRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceInvokeCommandResponseTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceCloseSessionRequestTable;
+extern "C" const fidl_type_t v1_fuchsia_tee_DeviceCloseSessionResponseTable;
+
+class Device final {
+ Device() = delete;
+ public:
+ static constexpr char Name[] = "fuchsia.tee.Device";
+
+ struct GetOsInfoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::tee::OsInfo info;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_DeviceGetOsInfoResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 136;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ using GetOsInfoRequest = ::fidl::AnyZeroArgMessage;
+
+ struct OpenSessionResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t session_id;
+ ::llcpp::fuchsia::tee::OpResult op_result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_DeviceOpenSessionResponseTable;
+ static constexpr uint32_t MaxNumHandles = 4;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 624;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct OpenSessionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::tee::Uuid trusted_app;
+ ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_DeviceOpenSessionRequestTable;
+ static constexpr uint32_t MaxNumHandles = 4;
+ static constexpr uint32_t PrimarySize = 48;
+ static constexpr uint32_t MaxOutOfLine = 544;
+ static constexpr uint32_t AltPrimarySize = 48;
+ static constexpr uint32_t AltMaxOutOfLine = 544;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = OpenSessionResponse;
+ };
+
+ struct InvokeCommandResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fuchsia::tee::OpResult op_result;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_DeviceInvokeCommandResponseTable;
+ static constexpr uint32_t MaxNumHandles = 4;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 624;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kResponse;
+ };
+ struct InvokeCommandRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t session_id;
+ uint32_t command_id;
+ ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_DeviceInvokeCommandRequestTable;
+ static constexpr uint32_t MaxNumHandles = 4;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 544;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 544;
+ static constexpr bool HasFlexibleEnvelope = true;
+ static constexpr bool HasPointer = true;
+ static constexpr bool ContainsUnion = false;
+ static constexpr ::fidl::internal::TransactionalMessageKind MessageKind =
+ ::fidl::internal::TransactionalMessageKind::kRequest;
+ using ResponseType = InvokeCommandResponse;
+ };
+
+ using CloseSessionResponse = ::fidl::AnyZeroArgMessage;
+ struct CloseSessionRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ uint32_t session_id;
+
+ static constexpr const fidl_type_t* Type = &v1_fuchsia_tee_DeviceCloseSessionRequestTable;
+ 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;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class GetOsInfo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ GetOsInfo_Impl(::zx::unowned_channel _client_end);
+ ~GetOsInfo_Impl() = default;
+ GetOsInfo_Impl(GetOsInfo_Impl&& other) = default;
+ GetOsInfo_Impl& operator=(GetOsInfo_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 OpenSession_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ OpenSession_Impl(::zx::unowned_channel _client_end, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set);
+ ~OpenSession_Impl() = default;
+ OpenSession_Impl(OpenSession_Impl&& other) = default;
+ OpenSession_Impl& operator=(OpenSession_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 InvokeCommand_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ InvokeCommand_Impl(::zx::unowned_channel _client_end, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set);
+ ~InvokeCommand_Impl() = default;
+ InvokeCommand_Impl(InvokeCommand_Impl&& other) = default;
+ InvokeCommand_Impl& operator=(InvokeCommand_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 CloseSession_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CloseSession_Impl(::zx::unowned_channel _client_end, uint32_t session_id);
+ ~CloseSession_Impl() = default;
+ CloseSession_Impl(CloseSession_Impl&& other) = default;
+ CloseSession_Impl& operator=(CloseSession_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 GetOsInfo = GetOsInfo_Impl<GetOsInfoResponse>;
+ using OpenSession = OpenSession_Impl<OpenSessionResponse>;
+ using InvokeCommand = InvokeCommand_Impl<InvokeCommandResponse>;
+ using CloseSession = CloseSession_Impl<CloseSessionResponse>;
+ };
+
+ // 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 GetOsInfo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ GetOsInfo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~GetOsInfo_Impl() = default;
+ GetOsInfo_Impl(GetOsInfo_Impl&& other) = default;
+ GetOsInfo_Impl& operator=(GetOsInfo_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 OpenSession_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ OpenSession_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer);
+ ~OpenSession_Impl() = default;
+ OpenSession_Impl(OpenSession_Impl&& other) = default;
+ OpenSession_Impl& operator=(OpenSession_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 InvokeCommand_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ InvokeCommand_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer);
+ ~InvokeCommand_Impl() = default;
+ InvokeCommand_Impl(InvokeCommand_Impl&& other) = default;
+ InvokeCommand_Impl& operator=(InvokeCommand_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 CloseSession_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CloseSession_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t session_id, ::fidl::BytePart _response_buffer);
+ ~CloseSession_Impl() = default;
+ CloseSession_Impl(CloseSession_Impl&& other) = default;
+ CloseSession_Impl& operator=(CloseSession_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 GetOsInfo = GetOsInfo_Impl<GetOsInfoResponse>;
+ using OpenSession = OpenSession_Impl<OpenSessionResponse>;
+ using InvokeCommand = InvokeCommand_Impl<InvokeCommandResponse>;
+ using CloseSession = CloseSession_Impl<CloseSessionResponse>;
+ };
+
+ 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_; }
+
+ // Obtain information about the TEE OS
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ ResultOf::GetOsInfo GetOsInfo();
+
+ // Obtain information about the TEE OS
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::GetOsInfo GetOsInfo(::fidl::BytePart _response_buffer);
+
+ // Initiates a communication session with the specified trusted application.
+ // Request is heap-allocated. Response is heap-allocated.
+ ResultOf::OpenSession OpenSession(::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set);
+
+ // Initiates a communication session with the specified trusted application.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OpenSession OpenSession(::fidl::BytePart _request_buffer, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer);
+
+ // Requests the trusted application perform the provided command. The command is unique to the
+ // trusted application.
+ // Request is heap-allocated. Response is heap-allocated.
+ ResultOf::InvokeCommand InvokeCommand(uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set);
+
+ // Requests the trusted application perform the provided command. The command is unique to the
+ // trusted application.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::InvokeCommand InvokeCommand(::fidl::BytePart _request_buffer, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer);
+
+ // Closes an established session.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::CloseSession CloseSession(uint32_t session_id);
+
+ // Closes an established session.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CloseSession CloseSession(::fidl::BytePart _request_buffer, uint32_t session_id, ::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:
+
+ // Obtain information about the TEE OS
+ // Allocates 16 bytes of request buffer on the stack. Response is heap-allocated.
+ static ResultOf::GetOsInfo GetOsInfo(::zx::unowned_channel _client_end);
+
+ // Obtain information about the TEE OS
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::GetOsInfo GetOsInfo(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Initiates a communication session with the specified trusted application.
+ // Request is heap-allocated. Response is heap-allocated.
+ static ResultOf::OpenSession OpenSession(::zx::unowned_channel _client_end, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set);
+
+ // Initiates a communication session with the specified trusted application.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OpenSession OpenSession(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer);
+
+ // Requests the trusted application perform the provided command. The command is unique to the
+ // trusted application.
+ // Request is heap-allocated. Response is heap-allocated.
+ static ResultOf::InvokeCommand InvokeCommand(::zx::unowned_channel _client_end, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set);
+
+ // Requests the trusted application perform the provided command. The command is unique to the
+ // trusted application.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::InvokeCommand InvokeCommand(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, ::fidl::BytePart _response_buffer);
+
+ // Closes an established session.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::CloseSession CloseSession(::zx::unowned_channel _client_end, uint32_t session_id);
+
+ // Closes an established session.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CloseSession CloseSession(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, uint32_t session_id, ::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:
+
+ // Obtain information about the TEE OS
+ static ::fidl::DecodeResult<GetOsInfoResponse> GetOsInfo(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Initiates a communication session with the specified trusted application.
+ static ::fidl::DecodeResult<OpenSessionResponse> OpenSession(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OpenSessionRequest> params, ::fidl::BytePart response_buffer);
+
+ // Requests the trusted application perform the provided command. The command is unique to the
+ // trusted application.
+ static ::fidl::DecodeResult<InvokeCommandResponse> InvokeCommand(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<InvokeCommandRequest> params, ::fidl::BytePart response_buffer);
+
+ // Closes an established session.
+ static ::fidl::DecodeResult<CloseSessionResponse> CloseSession(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CloseSessionRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Device;
+ using _Base = ::fidl::CompleterBase;
+
+ class GetOsInfoCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::tee::OsInfo info);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::tee::OsInfo info);
+ void Reply(::fidl::DecodedMessage<GetOsInfoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using GetOsInfoCompleter = ::fidl::Completer<GetOsInfoCompleterBase>;
+
+ virtual void GetOsInfo(GetOsInfoCompleter::Sync _completer) = 0;
+
+ class OpenSessionCompleterBase : public _Base {
+ public:
+ void Reply(uint32_t session_id, ::llcpp::fuchsia::tee::OpResult op_result);
+ void Reply(::fidl::BytePart _buffer, uint32_t session_id, ::llcpp::fuchsia::tee::OpResult op_result);
+ void Reply(::fidl::DecodedMessage<OpenSessionResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using OpenSessionCompleter = ::fidl::Completer<OpenSessionCompleterBase>;
+
+ virtual void OpenSession(::llcpp::fuchsia::tee::Uuid trusted_app, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, OpenSessionCompleter::Sync _completer) = 0;
+
+ class InvokeCommandCompleterBase : public _Base {
+ public:
+ void Reply(::llcpp::fuchsia::tee::OpResult op_result);
+ void Reply(::fidl::BytePart _buffer, ::llcpp::fuchsia::tee::OpResult op_result);
+ void Reply(::fidl::DecodedMessage<InvokeCommandResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using InvokeCommandCompleter = ::fidl::Completer<InvokeCommandCompleterBase>;
+
+ virtual void InvokeCommand(uint32_t session_id, uint32_t command_id, ::fidl::VectorView<::llcpp::fuchsia::tee::Parameter> parameter_set, InvokeCommandCompleter::Sync _completer) = 0;
+
+ class CloseSessionCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseSessionCompleter = ::fidl::Completer<CloseSessionCompleterBase>;
+
+ virtual void CloseSession(uint32_t session_id, CloseSessionCompleter::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 GetOsInfoRequest(const ::fidl::DecodedMessage<Device::GetOsInfoRequest>& _msg);
+ static void GetOsInfoResponse(const ::fidl::DecodedMessage<Device::GetOsInfoResponse>& _msg);
+ static void OpenSessionRequest(const ::fidl::DecodedMessage<Device::OpenSessionRequest>& _msg);
+ static void OpenSessionResponse(const ::fidl::DecodedMessage<Device::OpenSessionResponse>& _msg);
+ static void InvokeCommandRequest(const ::fidl::DecodedMessage<Device::InvokeCommandRequest>& _msg);
+ static void InvokeCommandResponse(const ::fidl::DecodedMessage<Device::InvokeCommandResponse>& _msg);
+ static void CloseSessionRequest(const ::fidl::DecodedMessage<Device::CloseSessionRequest>& _msg);
+ static void CloseSessionResponse(const ::fidl::DecodedMessage<Device::CloseSessionResponse>& _msg);
+ };
+};
+
+} // namespace tee
+} // namespace fuchsia
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Uuid> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::tee::Uuid>);
+static_assert(offsetof(::llcpp::fuchsia::tee::Uuid, time_low) == 0);
+static_assert(offsetof(::llcpp::fuchsia::tee::Uuid, time_mid) == 4);
+static_assert(offsetof(::llcpp::fuchsia::tee::Uuid, time_hi_and_version) == 6);
+static_assert(offsetof(::llcpp::fuchsia::tee::Uuid, clock_seq_and_node) == 8);
+static_assert(sizeof(::llcpp::fuchsia::tee::Uuid) == ::llcpp::fuchsia::tee::Uuid::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::OsRevision> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::tee::OsRevision>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::OsInfo> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::tee::OsInfo>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::None> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::tee::None>);
+static_assert(offsetof(::llcpp::fuchsia::tee::None, __reserved) == 0);
+static_assert(sizeof(::llcpp::fuchsia::tee::None) == ::llcpp::fuchsia::tee::None::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Value> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::tee::Value>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Buffer> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::tee::Buffer>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Parameter> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::tee::Parameter>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::OpResult> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fuchsia::tee::OpResult>);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Device::GetOsInfoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::tee::Device::GetOsInfoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::tee::Device::GetOsInfoResponse)
+ == ::llcpp::fuchsia::tee::Device::GetOsInfoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::GetOsInfoResponse, info) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Device::OpenSessionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::tee::Device::OpenSessionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::tee::Device::OpenSessionRequest)
+ == ::llcpp::fuchsia::tee::Device::OpenSessionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::OpenSessionRequest, trusted_app) == 16);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::OpenSessionRequest, parameter_set) == 32);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Device::OpenSessionResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::tee::Device::OpenSessionResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::tee::Device::OpenSessionResponse)
+ == ::llcpp::fuchsia::tee::Device::OpenSessionResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::OpenSessionResponse, session_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::OpenSessionResponse, op_result) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Device::InvokeCommandRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::tee::Device::InvokeCommandRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::tee::Device::InvokeCommandRequest)
+ == ::llcpp::fuchsia::tee::Device::InvokeCommandRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::InvokeCommandRequest, session_id) == 16);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::InvokeCommandRequest, command_id) == 20);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::InvokeCommandRequest, parameter_set) == 24);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Device::InvokeCommandResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::tee::Device::InvokeCommandResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::tee::Device::InvokeCommandResponse)
+ == ::llcpp::fuchsia::tee::Device::InvokeCommandResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::InvokeCommandResponse, op_result) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fuchsia::tee::Device::CloseSessionRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fuchsia::tee::Device::CloseSessionRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fuchsia::tee::Device::CloseSessionRequest)
+ == ::llcpp::fuchsia::tee::Device::CloseSessionRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fuchsia::tee::Device::CloseSessionRequest, session_id) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/ulib/fidl-async/test/BUILD.gn b/zircon/system/ulib/fidl-async/test/BUILD.gn
index be27c8c..7075e17 100644
--- a/zircon/system/ulib/fidl-async/test/BUILD.gn
+++ b/zircon/system/ulib/fidl-async/test/BUILD.gn
@@ -2,31 +2,25 @@
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
-import("$zx/public/gn/fidl.gni")
import("$zx/public/gn/fuzzer.gni")
-if (current_toolchain != default_toolchain) {
- zx_test("fidl-async-test") {
- sources = [
- "llcpp_async_bind_test.cc",
- "llcpp_bind_test.cc",
- "llcpp_channel_transaction_test.cc",
- ]
- deps = [
- ":fidl.test.simple.llcpp",
- "$zx/system/ulib/async:async-cpp",
- "$zx/system/ulib/async-loop:async-loop-cpp",
- "$zx/system/ulib/async-loop:async-loop-default.static",
- "$zx/system/ulib/fdio",
- "$zx/system/ulib/fidl:fidl-llcpp",
- "$zx/system/ulib/fidl-async:fidl-async-cpp",
- "$zx/system/ulib/sync",
- "$zx/system/ulib/zxtest",
- ]
- }
-}
-
-fidl_library("fidl.test.simple") {
- visibility = [ ":*" ]
- sources = [ "simple.test.fidl" ]
+zx_test("fidl-async-test") {
+ sources = [
+ "generated/fidl_llcpp_simple.test.cc",
+ "generated/fidl_llcpp_tables_simple.test.c",
+ "llcpp_async_bind_test.cc",
+ "llcpp_bind_test.cc",
+ "llcpp_channel_transaction_test.cc",
+ ]
+ include_dirs = [ "generated" ]
+ deps = [
+ "$zx/system/ulib/async:async-cpp",
+ "$zx/system/ulib/async-loop:async-loop-cpp",
+ "$zx/system/ulib/async-loop:async-loop-default.static",
+ "$zx/system/ulib/fdio",
+ "$zx/system/ulib/fidl:fidl-llcpp",
+ "$zx/system/ulib/fidl-async:fidl-async-cpp",
+ "$zx/system/ulib/sync",
+ "$zx/system/ulib/zxtest",
+ ]
}
diff --git a/zircon/system/ulib/fidl-async/test/gen_llcpp.sh b/zircon/system/ulib/fidl-async/test/gen_llcpp.sh
new file mode 100755
index 0000000..a4b7391
--- /dev/null
+++ b/zircon/system/ulib/fidl-async/test/gen_llcpp.sh
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+
+set -eu
+set -o pipefail
+
+LLCPP_TEST_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+FUCHSIA_DIR="$( echo ${LLCPP_TEST_DIR} | sed -e 's,zircon/system/utest.*$,,' )"
+
+if [ -z ${FUCHSIA_BUILD_DIR+x} ]; then
+ echo "please use fx exec to run this script" 1>&2
+ exit 1
+fi
+
+FIDLC=${FUCHSIA_BUILD_DIR}/host_x64/fidlc
+FIDLGEN=${FUCHSIA_BUILD_DIR}/host_x64/fidlgen_llcpp
+
+if [ ! -x "${FIDLC}" ]; then
+ echo "error: fidlc missing; did you fx clean-build?" 1>&2
+ exit 1
+fi
+
+if [ ! -x "${FIDLGEN}" ]; then
+ echo "error: fidlgen_llcpp missing; did you fx clean-build?" 1>&2
+ exit 1
+fi
+
+cd ${FUCHSIA_DIR}
+
+for src_path in `find "${LLCPP_TEST_DIR}" -name '*.fidl'`; do
+ src_name="$( basename "${src_path}" .fidl )"
+ json_name=${src_name}.json
+
+ # generate the json IR
+ cd ${LLCPP_TEST_DIR}
+ ${FIDLC} --json /tmp/${json_name} \
+ --tables generated/fidl_llcpp_tables_${src_name}.c \
+ --files ${src_path}
+
+ # generate llcpp bindings
+ ${FIDLGEN} -json /tmp/${json_name} \
+ -header fidl_llcpp_${src_name}.h \
+ -source fidl_llcpp_${src_name}.cc \
+ -include-base .
+
+ # move bindings to the `generated` directory
+ mv fidl_llcpp_${src_name}.h ${LLCPP_TEST_DIR}/generated
+ mv fidl_llcpp_${src_name}.cc ${LLCPP_TEST_DIR}/generated
+
+ # cleanup
+ rm /tmp/${json_name}
+done
diff --git a/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_simple.test.cc b/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_simple.test.cc
new file mode 100644
index 0000000..25d11b0
--- /dev/null
+++ b/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_simple.test.cc
@@ -0,0 +1,302 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fidl_llcpp_simple.test.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace simple {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kSimple_Echo_Ordinal = 0x7d54c5da00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSimple_Echo_GenOrdinal = 0x6a70325976d7cc68lu;
+extern "C" const fidl_type_t fidl_test_simple_SimpleEchoRequestTable;
+extern "C" const fidl_type_t fidl_test_simple_SimpleEchoResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_simple_SimpleEchoResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kSimple_Close_Ordinal = 0x48270ef100000000lu;
+[[maybe_unused]]
+constexpr uint64_t kSimple_Close_GenOrdinal = 0x49b6e6b3b17ebc97lu;
+extern "C" const fidl_type_t fidl_test_simple_SimpleCloseRequestTable;
+extern "C" const fidl_type_t fidl_test_simple_SimpleCloseResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_simple_SimpleCloseResponseTable;
+
+} // namespace
+template <>
+Simple::ResultOf::Echo_Impl<Simple::EchoResponse>::Echo_Impl(::zx::unowned_channel _client_end, int32_t request) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EchoRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, EchoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<EchoRequest*>(_write_bytes);
+ _request.request = std::move(request);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(EchoRequest));
+ ::fidl::DecodedMessage<EchoRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Simple::InPlace::Echo(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Simple::ResultOf::Echo Simple::SyncClient::Echo(int32_t request) {
+ return ResultOf::Echo(::zx::unowned_channel(this->channel_), std::move(request));
+}
+
+Simple::ResultOf::Echo Simple::Call::Echo(::zx::unowned_channel _client_end, int32_t request) {
+ return ResultOf::Echo(std::move(_client_end), std::move(request));
+}
+
+template <>
+Simple::UnownedResultOf::Echo_Impl<Simple::EchoResponse>::Echo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t request, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < EchoRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<EchoResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, EchoRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<EchoRequest*>(_request_buffer.data());
+ _request.request = std::move(request);
+ _request_buffer.set_actual(sizeof(EchoRequest));
+ ::fidl::DecodedMessage<EchoRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Simple::InPlace::Echo(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Simple::UnownedResultOf::Echo Simple::SyncClient::Echo(::fidl::BytePart _request_buffer, int32_t request, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Echo(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(request), std::move(_response_buffer));
+}
+
+Simple::UnownedResultOf::Echo Simple::Call::Echo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t request, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Echo(std::move(_client_end), std::move(_request_buffer), std::move(request), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Simple::EchoResponse> Simple::InPlace::Echo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EchoRequest> params, ::fidl::BytePart response_buffer) {
+ Simple::SetTransactionHeaderFor::EchoRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Simple::EchoResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<EchoRequest, EchoResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Simple::EchoResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+Simple::ResultOf::Close_Impl<Simple::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, CloseRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Simple::InPlace::Close(std::move(_client_end), Super::response_buffer()));
+}
+
+Simple::ResultOf::Close Simple::SyncClient::Close() {
+ return ResultOf::Close(::zx::unowned_channel(this->channel_));
+}
+
+Simple::ResultOf::Close Simple::Call::Close(::zx::unowned_channel _client_end) {
+ return ResultOf::Close(std::move(_client_end));
+}
+
+template <>
+Simple::UnownedResultOf::Close_Impl<Simple::CloseResponse>::Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(CloseRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, CloseRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(CloseRequest));
+ ::fidl::DecodedMessage<CloseRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Simple::InPlace::Close(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Simple::UnownedResultOf::Close Simple::SyncClient::Close(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Simple::UnownedResultOf::Close Simple::Call::Close(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Close(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Simple::CloseResponse> Simple::InPlace::Close(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(CloseRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<CloseRequest> params(std::move(_request_buffer));
+ Simple::SetTransactionHeaderFor::CloseRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Simple::CloseResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CloseRequest, CloseResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Simple::CloseResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Simple::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kSimple_Echo_Ordinal:
+ case kSimple_Echo_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EchoRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->Echo(std::move(message->request),
+ Interface::EchoCompleter::Sync(txn));
+ return true;
+ }
+ case kSimple_Close_Ordinal:
+ case kSimple_Close_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CloseRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Close(
+ Interface::CloseCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Simple::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Simple::Interface::EchoCompleterBase::Reply(int32_t reply) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EchoResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<EchoResponse*>(_write_bytes);
+ Simple::SetTransactionHeaderFor::EchoResponse(
+ ::fidl::DecodedMessage<EchoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EchoResponse::PrimarySize,
+ EchoResponse::PrimarySize)));
+ _response.reply = std::move(reply);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(EchoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EchoResponse>(std::move(_response_bytes)));
+}
+
+void Simple::Interface::EchoCompleterBase::Reply(::fidl::BytePart _buffer, int32_t reply) {
+ if (_buffer.capacity() < EchoResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<EchoResponse*>(_buffer.data());
+ Simple::SetTransactionHeaderFor::EchoResponse(
+ ::fidl::DecodedMessage<EchoResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EchoResponse::PrimarySize,
+ EchoResponse::PrimarySize)));
+ _response.reply = std::move(reply);
+ _buffer.set_actual(sizeof(EchoResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<EchoResponse>(std::move(_buffer)));
+}
+
+void Simple::Interface::EchoCompleterBase::Reply(::fidl::DecodedMessage<EchoResponse> params) {
+ Simple::SetTransactionHeaderFor::EchoResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void Simple::Interface::CloseCompleterBase::Reply(int32_t v) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CloseResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CloseResponse*>(_write_bytes);
+ Simple::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.v = std::move(v);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_response_bytes)));
+}
+
+void Simple::Interface::CloseCompleterBase::Reply(::fidl::BytePart _buffer, int32_t v) {
+ if (_buffer.capacity() < CloseResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CloseResponse*>(_buffer.data());
+ Simple::SetTransactionHeaderFor::CloseResponse(
+ ::fidl::DecodedMessage<CloseResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CloseResponse::PrimarySize,
+ CloseResponse::PrimarySize)));
+ _response.v = std::move(v);
+ _buffer.set_actual(sizeof(CloseResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CloseResponse>(std::move(_buffer)));
+}
+
+void Simple::Interface::CloseCompleterBase::Reply(::fidl::DecodedMessage<CloseResponse> params) {
+ Simple::SetTransactionHeaderFor::CloseResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Simple::SetTransactionHeaderFor::EchoRequest(const ::fidl::DecodedMessage<Simple::EchoRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSimple_Echo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Simple::SetTransactionHeaderFor::EchoResponse(const ::fidl::DecodedMessage<Simple::EchoResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSimple_Echo_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void Simple::SetTransactionHeaderFor::CloseRequest(const ::fidl::DecodedMessage<Simple::CloseRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSimple_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Simple::SetTransactionHeaderFor::CloseResponse(const ::fidl::DecodedMessage<Simple::CloseResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kSimple_Close_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace simple
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
diff --git a/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_simple.test.h b/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_simple.test.h
new file mode 100644
index 0000000..2f61137
--- /dev/null
+++ b/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_simple.test.h
@@ -0,0 +1,352 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace simple {
+
+class Simple;
+
+extern "C" const fidl_type_t fidl_test_simple_SimpleEchoRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_simple_SimpleEchoRequestTable;
+extern "C" const fidl_type_t fidl_test_simple_SimpleEchoResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_simple_SimpleEchoResponseTable;
+extern "C" const fidl_type_t fidl_test_simple_SimpleCloseRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_simple_SimpleCloseRequestTable;
+extern "C" const fidl_type_t fidl_test_simple_SimpleCloseResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_simple_SimpleCloseResponseTable;
+
+class Simple final {
+ Simple() = delete;
+ public:
+
+ struct EchoResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t reply;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_simple_SimpleEchoResponseTable;
+ static constexpr const fidl_type_t* AltType = &fidl_test_simple_SimpleEchoResponseTable;
+ 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::kResponse;
+ };
+ struct EchoRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t request;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_simple_SimpleEchoRequestTable;
+ static constexpr const fidl_type_t* AltType = &fidl_test_simple_SimpleEchoRequestTable;
+ 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 = EchoResponse;
+ };
+
+ struct CloseResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t v;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_simple_SimpleCloseResponseTable;
+ static constexpr const fidl_type_t* AltType = &fidl_test_simple_SimpleCloseResponseTable;
+ 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::kResponse;
+ };
+ using CloseRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Echo_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Echo_Impl(::zx::unowned_channel _client_end, int32_t request);
+ ~Echo_Impl() = default;
+ Echo_Impl(Echo_Impl&& other) = default;
+ Echo_Impl& operator=(Echo_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 Close_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Echo = Echo_Impl<EchoResponse>;
+ using Close = Close_Impl<CloseResponse>;
+ };
+
+ // 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 Echo_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Echo_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t request, ::fidl::BytePart _response_buffer);
+ ~Echo_Impl() = default;
+ Echo_Impl(Echo_Impl&& other) = default;
+ Echo_Impl& operator=(Echo_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 Close_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Close_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Close_Impl() = default;
+ Close_Impl(Close_Impl&& other) = default;
+ Close_Impl& operator=(Close_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 Echo = Echo_Impl<EchoResponse>;
+ using Close = Close_Impl<CloseResponse>;
+ };
+
+ 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_; }
+
+ // Replies with the value requested.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Echo Echo(int32_t request);
+
+ // Replies with the value requested.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Echo Echo(::fidl::BytePart _request_buffer, int32_t request, ::fidl::BytePart _response_buffer);
+
+ // Never actually replies. Just closes instead.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Close Close();
+
+ // Never actually replies. Just closes instead.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Close Close(::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:
+
+ // Replies with the value requested.
+ // Allocates 48 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Echo Echo(::zx::unowned_channel _client_end, int32_t request);
+
+ // Replies with the value requested.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Echo Echo(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, int32_t request, ::fidl::BytePart _response_buffer);
+
+ // Never actually replies. Just closes instead.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Close Close(::zx::unowned_channel _client_end);
+
+ // Never actually replies. Just closes instead.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Close Close(::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:
+
+ // Replies with the value requested.
+ static ::fidl::DecodeResult<EchoResponse> Echo(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EchoRequest> params, ::fidl::BytePart response_buffer);
+
+ // Never actually replies. Just closes instead.
+ static ::fidl::DecodeResult<CloseResponse> Close(::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 = Simple;
+ using _Base = ::fidl::CompleterBase;
+
+ class EchoCompleterBase : public _Base {
+ public:
+ void Reply(int32_t reply);
+ void Reply(::fidl::BytePart _buffer, int32_t reply);
+ void Reply(::fidl::DecodedMessage<EchoResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using EchoCompleter = ::fidl::Completer<EchoCompleterBase>;
+
+ virtual void Echo(int32_t request, EchoCompleter::Sync _completer) = 0;
+
+ class CloseCompleterBase : public _Base {
+ public:
+ void Reply(int32_t v);
+ void Reply(::fidl::BytePart _buffer, int32_t v);
+ void Reply(::fidl::DecodedMessage<CloseResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CloseCompleter = ::fidl::Completer<CloseCompleterBase>;
+
+ virtual void Close(CloseCompleter::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 EchoRequest(const ::fidl::DecodedMessage<Simple::EchoRequest>& _msg);
+ static void EchoResponse(const ::fidl::DecodedMessage<Simple::EchoResponse>& _msg);
+ static void CloseRequest(const ::fidl::DecodedMessage<Simple::CloseRequest>& _msg);
+ static void CloseResponse(const ::fidl::DecodedMessage<Simple::CloseResponse>& _msg);
+ };
+};
+
+} // namespace simple
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::simple::Simple::EchoRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::simple::Simple::EchoRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::simple::Simple::EchoRequest)
+ == ::llcpp::fidl::test::simple::Simple::EchoRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::simple::Simple::EchoRequest, request) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::simple::Simple::EchoResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::simple::Simple::EchoResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::simple::Simple::EchoResponse)
+ == ::llcpp::fidl::test::simple::Simple::EchoResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::simple::Simple::EchoResponse, reply) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::simple::Simple::CloseResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::simple::Simple::CloseResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::simple::Simple::CloseResponse)
+ == ::llcpp::fidl::test::simple::Simple::CloseResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::simple::Simple::CloseResponse, v) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_tables_simple.test.c b/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_tables_simple.test.c
new file mode 100644
index 0000000..db9017a
--- /dev/null
+++ b/zircon/system/ulib/fidl-async/test/generated/fidl_llcpp_tables_simple.test.c
@@ -0,0 +1,69 @@
+// WARNING: This file is machine generated by fidlc.
+
+#include <lib/fidl/internal.h>
+
+// Forward declarations for old <-> V1 mappings
+
+extern const fidl_type_t fidl_test_simple_SimpleEchoRequestTable;
+extern const fidl_type_t fidl_test_simple_SimpleEchoResponseTable;
+extern const fidl_type_t fidl_test_simple_SimpleCloseRequestTable;
+extern const fidl_type_t fidl_test_simple_SimpleCloseResponseTable;
+extern const fidl_type_t v1_fidl_test_simple_SimpleEchoRequestTable;
+extern const fidl_type_t v1_fidl_test_simple_SimpleEchoResponseTable;
+extern const fidl_type_t v1_fidl_test_simple_SimpleCloseRequestTable;
+extern const fidl_type_t v1_fidl_test_simple_SimpleCloseResponseTable;
+
+// Coding tables for old wire format.
+
+
+
+extern const fidl_type_t fidl_test_simple_SimpleEchoRequestTable;
+static const struct FidlStructField Fields34fidl_test_simple_SimpleEchoRequest[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u}
+};
+const fidl_type_t fidl_test_simple_SimpleEchoRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields34fidl_test_simple_SimpleEchoRequest, .field_count=1u, .size=24u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.simple/SimpleEchoRequest", .alt_type=&v1_fidl_test_simple_SimpleEchoRequestTable}}};
+
+extern const fidl_type_t fidl_test_simple_SimpleEchoResponseTable;
+static const struct FidlStructField Fields35fidl_test_simple_SimpleEchoResponse[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u}
+};
+const fidl_type_t fidl_test_simple_SimpleEchoResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35fidl_test_simple_SimpleEchoResponse, .field_count=1u, .size=24u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.simple/SimpleEchoResponse", .alt_type=&v1_fidl_test_simple_SimpleEchoResponseTable}}};
+
+extern const fidl_type_t fidl_test_simple_SimpleCloseRequestTable;
+static const struct FidlStructField Fields35fidl_test_simple_SimpleCloseRequest[] = {};
+const fidl_type_t fidl_test_simple_SimpleCloseRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35fidl_test_simple_SimpleCloseRequest, .field_count=0u, .size=16u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.simple/SimpleCloseRequest", .alt_type=&v1_fidl_test_simple_SimpleCloseRequestTable}}};
+
+extern const fidl_type_t fidl_test_simple_SimpleCloseResponseTable;
+static const struct FidlStructField Fields36fidl_test_simple_SimpleCloseResponse[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u}
+};
+const fidl_type_t fidl_test_simple_SimpleCloseResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields36fidl_test_simple_SimpleCloseResponse, .field_count=1u, .size=24u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.simple/SimpleCloseResponse", .alt_type=&v1_fidl_test_simple_SimpleCloseResponseTable}}};
+
+
+// Coding tables for v1 wire format.
+
+
+
+extern const fidl_type_t v1_fidl_test_simple_SimpleEchoRequestTable;
+static const struct FidlStructField Fields37v1_fidl_test_simple_SimpleEchoRequest[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u}
+};
+const fidl_type_t v1_fidl_test_simple_SimpleEchoRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields37v1_fidl_test_simple_SimpleEchoRequest, .field_count=1u, .size=24u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.simple/SimpleEchoRequest", .alt_type=&fidl_test_simple_SimpleEchoRequestTable}}};
+
+extern const fidl_type_t v1_fidl_test_simple_SimpleEchoResponseTable;
+static const struct FidlStructField Fields38v1_fidl_test_simple_SimpleEchoResponse[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u}
+};
+const fidl_type_t v1_fidl_test_simple_SimpleEchoResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields38v1_fidl_test_simple_SimpleEchoResponse, .field_count=1u, .size=24u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.simple/SimpleEchoResponse", .alt_type=&fidl_test_simple_SimpleEchoResponseTable}}};
+
+extern const fidl_type_t v1_fidl_test_simple_SimpleCloseRequestTable;
+static const struct FidlStructField Fields38v1_fidl_test_simple_SimpleCloseRequest[] = {};
+const fidl_type_t v1_fidl_test_simple_SimpleCloseRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields38v1_fidl_test_simple_SimpleCloseRequest, .field_count=0u, .size=16u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.simple/SimpleCloseRequest", .alt_type=&fidl_test_simple_SimpleCloseRequestTable}}};
+
+extern const fidl_type_t v1_fidl_test_simple_SimpleCloseResponseTable;
+static const struct FidlStructField Fields39v1_fidl_test_simple_SimpleCloseResponse[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u}
+};
+const fidl_type_t v1_fidl_test_simple_SimpleCloseResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields39v1_fidl_test_simple_SimpleCloseResponse, .field_count=1u, .size=24u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.simple/SimpleCloseResponse", .alt_type=&fidl_test_simple_SimpleCloseResponseTable}}};
+
+
diff --git a/zircon/system/ulib/fidl-async/test/llcpp_async_bind_test.cc b/zircon/system/ulib/fidl-async/test/llcpp_async_bind_test.cc
index 72eeee4..660821b 100644
--- a/zircon/system/ulib/fidl-async/test/llcpp_async_bind_test.cc
+++ b/zircon/system/ulib/fidl-async/test/llcpp_async_bind_test.cc
@@ -14,9 +14,10 @@
#include <fbl/auto_lock.h>
#include <fbl/mutex.h>
-#include <fidl/test/simple/llcpp/fidl.h>
#include <zxtest/zxtest.h>
+#include "generated/fidl_llcpp_simple.test.h"
+
namespace {
constexpr uint32_t kNumberOfAsyncs = 10;
@@ -54,12 +55,12 @@
ASSERT_OK(zx::channel::create(0, &local, &remote));
sync_completion_t closed;
- fidl::OnUnboundFn<SyncServer> on_unbound = [&closed](SyncServer*, fidl::UnboundReason reason,
- zx::channel channel) {
- ASSERT_EQ(reason, fidl::UnboundReason::kPeerClosed);
- ASSERT_FALSE(channel);
- sync_completion_signal(&closed);
- };
+ fidl::OnUnboundFn<SyncServer> on_unbound =
+ [&closed](SyncServer*, fidl::UnboundReason reason, zx::channel channel) {
+ ASSERT_EQ(reason, fidl::UnboundReason::kPeerClosed);
+ ASSERT_FALSE(channel);
+ sync_completion_signal(&closed);
+ };
fidl::AsyncBind(loop.dispatcher(), std::move(remote), server.get(), std::move(on_unbound));
// Sync client call.
@@ -94,12 +95,12 @@
ASSERT_OK(zx::channel::create(0, &local, &remote));
sync_completion_t closed;
- fidl::OnUnboundFn<AsyncServer> on_unbound = [&closed](AsyncServer*, fidl::UnboundReason reason,
- zx::channel channel) {
- ASSERT_EQ(reason, fidl::UnboundReason::kPeerClosed);
- ASSERT_FALSE(channel);
- sync_completion_signal(&closed);
- };
+ fidl::OnUnboundFn<AsyncServer> on_unbound =
+ [&closed](AsyncServer*, fidl::UnboundReason reason, zx::channel channel) {
+ ASSERT_EQ(reason, fidl::UnboundReason::kPeerClosed);
+ ASSERT_FALSE(channel);
+ sync_completion_signal(&closed);
+ };
fidl::AsyncBind(main.dispatcher(), std::move(remote), server.get(), std::move(on_unbound));
// Sync client call.
@@ -290,12 +291,12 @@
zx::channel local, remote;
ASSERT_OK(zx::channel::create(0, &local, &remote));
- fidl::OnUnboundFn<Server> on_unbound = [](Server* server, fidl::UnboundReason reason,
- zx::channel channel) {
- ASSERT_EQ(reason, fidl::UnboundReason::kPeerClosed);
- ASSERT_FALSE(channel);
- delete server;
- };
+ fidl::OnUnboundFn<Server> on_unbound =
+ [](Server* server, fidl::UnboundReason reason, zx::channel channel) {
+ ASSERT_EQ(reason, fidl::UnboundReason::kPeerClosed);
+ ASSERT_FALSE(channel);
+ delete server;
+ };
fidl::AsyncBind(loop.dispatcher(), std::move(remote), server.release(), std::move(on_unbound));
loop.RunUntilIdle();
@@ -336,12 +337,12 @@
zx::channel local, remote;
ASSERT_OK(zx::channel::create(0, &local, &remote));
- fidl::OnUnboundFn<ErrorServer> on_unbound = [&error](ErrorServer*, fidl::UnboundReason reason,
- zx::channel channel) {
- ASSERT_EQ(reason, fidl::UnboundReason::kPeerClosed);
- ASSERT_FALSE(channel);
- sync_completion_signal(&error);
- };
+ fidl::OnUnboundFn<ErrorServer> on_unbound =
+ [&error](ErrorServer*, fidl::UnboundReason reason, zx::channel channel) {
+ ASSERT_EQ(reason, fidl::UnboundReason::kPeerClosed);
+ ASSERT_FALSE(channel);
+ sync_completion_signal(&error);
+ };
fidl::AsyncBind<ErrorServer>(loop.dispatcher(), std::move(remote), server.get(),
std::move(on_unbound));
@@ -481,11 +482,11 @@
zx::channel local, remote;
ASSERT_OK(zx::channel::create(0, &local, &remote));
- fidl::OnUnboundFn<ErrorServer> on_unbound = [&closed](ErrorServer*, fidl::UnboundReason,
- zx::channel channel) {
- ASSERT_FALSE(channel);
- sync_completion_signal(&closed);
- };
+ fidl::OnUnboundFn<ErrorServer> on_unbound =
+ [&closed](ErrorServer*, fidl::UnboundReason, zx::channel channel) {
+ ASSERT_FALSE(channel);
+ sync_completion_signal(&closed);
+ };
fidl::AsyncBind<ErrorServer>(loop.dispatcher(), std::move(remote), server.get(),
std::move(on_unbound));
@@ -532,11 +533,11 @@
zx::channel local, remote;
ASSERT_OK(zx::channel::create(0, &local, &remote));
- fidl::OnUnboundFn<Server> on_unbound = [](Server* server, fidl::UnboundReason,
- zx::channel channel) {
- ASSERT_FALSE(channel);
- delete server;
- };
+ fidl::OnUnboundFn<Server> on_unbound =
+ [](Server* server, fidl::UnboundReason, zx::channel channel) {
+ ASSERT_FALSE(channel);
+ delete server;
+ };
fidl::AsyncBind(loop.dispatcher(), std::move(remote), server.release(), std::move(on_unbound));
ASSERT_FALSE(sync_completion_signaled(&destroyed));
@@ -559,14 +560,15 @@
ASSERT_OK(zx::channel::create(0, &local, &remote));
auto remote_handle = remote.get();
- fidl::OnUnboundFn<Server> on_unbound = [remote_handle](Server*, fidl::UnboundReason reason,
- zx::channel channel) {
- ASSERT_EQ(reason, fidl::UnboundReason::kUnbind);
- ASSERT_EQ(channel.get(), remote_handle);
- channel.reset();
- };
- auto binding_ref = fidl::BindingRef::CreateAsyncBinding(main.dispatcher(), std::move(remote),
- server.get(), std::move(on_unbound));
+ fidl::OnUnboundFn<Server> on_unbound =
+ [remote_handle](Server*, fidl::UnboundReason reason, zx::channel channel) {
+ ASSERT_EQ(reason, fidl::UnboundReason::kUnbind);
+ ASSERT_EQ(channel.get(), remote_handle);
+ channel.reset();
+ };
+ auto binding_ref =
+ fidl::BindingRef::CreateAsyncBinding(main.dispatcher(), std::move(remote), server.get(),
+ std::move(on_unbound));
ASSERT_TRUE(binding_ref.is_ok());
main.RunUntilIdle();
@@ -611,8 +613,9 @@
ASSERT_EQ(channel.get(), remote_handle);
channel.reset(); // Release the handle to trigger ZX_ERR_PEER_CLOSED on the client.
};
- auto binding_ref = fidl::BindingRef::CreateAsyncBinding(loop.dispatcher(), std::move(remote),
- server.get(), std::move(on_unbound));
+ auto binding_ref =
+ fidl::BindingRef::CreateAsyncBinding(loop.dispatcher(), std::move(remote), server.get(),
+ std::move(on_unbound));
ASSERT_TRUE(binding_ref.is_ok());
// Wait until worker_start so we have an in-flight transaction.
@@ -660,8 +663,7 @@
constexpr int kMaxReqs = 10;
auto server = std::make_unique<ConcurrentSyncServer>(kMaxReqs);
async::Loop server_loop(&kAsyncLoopConfigNoAttachToCurrentThread);
- for (int i = 0; i < kMaxReqs; ++i)
- ASSERT_OK(server_loop.StartThread());
+ for (int i = 0; i < kMaxReqs; ++i) ASSERT_OK(server_loop.StartThread());
// Bind the server.
fidl::AsyncBind(server_loop.dispatcher(), std::move(remote), std::move(server));
@@ -670,15 +672,14 @@
std::vector<std::thread> threads;
for (int i = 0; i < kMaxReqs; ++i) {
threads.emplace_back([&] {
- auto result = ::llcpp::fidl::test::simple::Simple::Call::Echo(zx::unowned_channel{local},
- kExpectedReply);
- ASSERT_EQ(result.status(), ZX_OK);
- });
+ auto result = ::llcpp::fidl::test::simple::Simple::Call::Echo(
+ zx::unowned_channel{local}, kExpectedReply);
+ ASSERT_EQ(result.status(), ZX_OK);
+ });
}
// Join the client threads.
- for (auto& thread : threads)
- thread.join();
+ for (auto& thread : threads) thread.join();
}
TEST(AsyncBindTestCase, ConcurrentIdempotentClose) {
@@ -700,8 +701,7 @@
constexpr int kMaxReqs = 10;
auto server = std::make_unique<ConcurrentSyncServer>();
async::Loop server_loop(&kAsyncLoopConfigNoAttachToCurrentThread);
- for (int i = 0; i < kMaxReqs; ++i)
- ASSERT_OK(server_loop.StartThread());
+ for (int i = 0; i < kMaxReqs; ++i) ASSERT_OK(server_loop.StartThread());
// Bind the server.
fidl::OnUnboundFn<ConcurrentSyncServer> on_unbound =
@@ -717,14 +717,14 @@
std::vector<std::thread> threads;
for (int i = 0; i < kMaxReqs; ++i) {
threads.emplace_back([&] {
- auto result = ::llcpp::fidl::test::simple::Simple::Call::Close(zx::unowned_channel{local});
- ASSERT_EQ(result.status(), ZX_ERR_PEER_CLOSED);
- });
+ auto result = ::llcpp::fidl::test::simple::Simple::Call::Close(
+ zx::unowned_channel{local});
+ ASSERT_EQ(result.status(), ZX_ERR_PEER_CLOSED);
+ });
}
// Join the client threads.
- for (auto& thread : threads)
- thread.join();
+ for (auto& thread : threads) thread.join();
}
TEST(AsyncBindTestCase, UnbindBeforeClose) {
@@ -754,8 +754,9 @@
ASSERT_EQ(remote_handle, channel.get());
channel.reset();
};
- auto binding_ref = fidl::BindingRef::CreateAsyncBinding(
- server_loop.dispatcher(), std::move(remote), server.get(), std::move(on_unbound));
+ auto binding_ref =
+ fidl::BindingRef::CreateAsyncBinding(server_loop.dispatcher(), std::move(remote),
+ server.get(), std::move(on_unbound));
ASSERT_TRUE(binding_ref.is_ok());
// Give the BindingRef to the server so it can call Unbind().
@@ -784,14 +785,15 @@
ASSERT_OK(server_loop.StartThread());
// Bind the channel.
- fidl::OnUnboundFn<UnbindServer> on_unbound = [](UnbindServer*, fidl::UnboundReason reason,
- zx::channel channel) {
- ASSERT_EQ(fidl::UnboundReason::kUnbind, reason);
- // Close() precedes Unbind(), so the channel will have been closed.
- ASSERT_FALSE(channel);
- };
- auto binding_ref = fidl::BindingRef::CreateAsyncBinding(
- server_loop.dispatcher(), std::move(remote), server.get(), std::move(on_unbound));
+ fidl::OnUnboundFn<UnbindServer> on_unbound =
+ [](UnbindServer*, fidl::UnboundReason reason, zx::channel channel) {
+ ASSERT_EQ(fidl::UnboundReason::kUnbind, reason);
+ // Close() precedes Unbind(), so the channel will have been closed.
+ ASSERT_FALSE(channel);
+ };
+ auto binding_ref =
+ fidl::BindingRef::CreateAsyncBinding(server_loop.dispatcher(), std::move(remote),
+ server.get(), std::move(on_unbound));
ASSERT_TRUE(binding_ref.is_ok());
// Give the BindingRef to the server so it can call Unbind().
diff --git a/zircon/system/ulib/fidl-async/test/llcpp_bind_test.cc b/zircon/system/ulib/fidl-async/test/llcpp_bind_test.cc
index daff160..d71b92c 100644
--- a/zircon/system/ulib/fidl-async/test/llcpp_bind_test.cc
+++ b/zircon/system/ulib/fidl-async/test/llcpp_bind_test.cc
@@ -7,9 +7,10 @@
#include <lib/fidl-async/cpp/bind.h>
#include <lib/sync/completion.h>
-#include <fidl/test/simple/llcpp/fidl.h>
#include <zxtest/zxtest.h>
+#include "generated/fidl_llcpp_simple.test.h"
+
namespace {
class Server : public ::llcpp::fidl::test::simple::Simple::Interface {
diff --git a/zircon/system/utest/fidl-llcpp-interop/BUILD.gn b/zircon/system/utest/fidl-llcpp-interop/BUILD.gn
index 54de54d..6b1fc98 100644
--- a/zircon/system/utest/fidl-llcpp-interop/BUILD.gn
+++ b/zircon/system/utest/fidl-llcpp-interop/BUILD.gn
@@ -13,14 +13,15 @@
"basictypes_tests.cc",
"controlflow_tests.cc",
"dirent_tests.cc",
+ "generated/fidl_llcpp_basictypes.test.cc",
+ "generated/fidl_llcpp_controlflow.cc",
+ "generated/fidl_llcpp_dirent.cc",
]
+ include_dirs = [ "generated" ]
deps = [
":fidl.test.llcpp.basictypes.c",
- ":fidl.test.llcpp.basictypes.llcpp",
":fidl.test.llcpp.controlflow.c",
- ":fidl.test.llcpp.controlflow.llcpp",
":fidl.test.llcpp.dirent.c",
- ":fidl.test.llcpp.dirent.llcpp",
"$zx/system/ulib/async:async-cpp",
"$zx/system/ulib/async:async-default",
"$zx/system/ulib/async-loop:async-loop-cpp",
diff --git a/zircon/system/utest/fidl-llcpp-interop/basictypes_tests.cc b/zircon/system/utest/fidl-llcpp-interop/basictypes_tests.cc
index 0dca576..a58d803 100644
--- a/zircon/system/utest/fidl-llcpp-interop/basictypes_tests.cc
+++ b/zircon/system/utest/fidl-llcpp-interop/basictypes_tests.cc
@@ -2,8 +2,10 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <fidl/test/llcpp/basictypes/c/fidl.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
+#include <lib/async-loop/default.h>
#include <lib/async-loop/loop.h>
#include <lib/fidl-async/bind.h>
#include <lib/fidl-async/cpp/bind.h>
@@ -14,16 +16,14 @@
#include <string.h>
#include <zircon/fidl.h>
#include <zircon/syscalls.h>
+#include <zxtest/zxtest.h>
#include <atomic>
#include <memory>
#include <utility>
-#include <fidl/test/llcpp/basictypes/c/fidl.h>
-#include <zxtest/zxtest.h>
-
// Interface under test
-#include <fidl/test/llcpp/basictypes/llcpp/fidl.h>
+#include "generated/fidl_llcpp_basictypes.test.h"
namespace basictypes = llcpp::fidl::test::llcpp::basictypes;
diff --git a/zircon/system/utest/fidl-llcpp-interop/controlflow_tests.cc b/zircon/system/utest/fidl-llcpp-interop/controlflow_tests.cc
index ee476b2..a047b04 100644
--- a/zircon/system/utest/fidl-llcpp-interop/controlflow_tests.cc
+++ b/zircon/system/utest/fidl-llcpp-interop/controlflow_tests.cc
@@ -27,7 +27,7 @@
#include <zxtest/zxtest.h>
// Interface under test
-#include <fidl/test/llcpp/controlflow/llcpp/fidl.h>
+#include "generated/fidl_llcpp_controlflow.h"
// Control flow tests: manually interact with a server and test for epitaph and shutdown.
namespace {
@@ -175,9 +175,8 @@
// Manually write the epitaph request message, since the epitaph will cause the C bindings
// to fail.
fidl_test_llcpp_controlflow_ControlFlowMustSendAccessDeniedEpitaphRequest request = {};
- fidl_init_txn_header(
- &request.hdr, 0,
- fidl_test_llcpp_controlflow_ControlFlowMustSendAccessDeniedEpitaphGenOrdinal);
+ fidl_init_txn_header(&request.hdr, 0,
+ fidl_test_llcpp_controlflow_ControlFlowMustSendAccessDeniedEpitaphGenOrdinal);
ASSERT_OK(client_chan.write(0, &request, sizeof(request), nullptr, 0));
ASSERT_NO_FATAL_FAILURES(WaitUntilNextIteration(loop->dispatcher()));
diff --git a/zircon/system/utest/fidl-llcpp-interop/dirent_tests.cc b/zircon/system/utest/fidl-llcpp-interop/dirent_tests.cc
index 23bddad..8041d92 100644
--- a/zircon/system/utest/fidl-llcpp-interop/dirent_tests.cc
+++ b/zircon/system/utest/fidl-llcpp-interop/dirent_tests.cc
@@ -2,8 +2,10 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
+#include <fidl/test/llcpp/dirent/c/fidl.h>
#include <lib/async-loop/cpp/loop.h>
#include <lib/async-loop/default.h>
+#include <lib/async-loop/default.h>
#include <lib/async-loop/loop.h>
#include <lib/async/cpp/task.h>
#include <lib/fidl-async/cpp/bind.h>
@@ -15,6 +17,7 @@
#include <lib/zx/time.h>
#include <zircon/fidl.h>
#include <zircon/syscalls.h>
+#include <zxtest/zxtest.h>
#include <atomic>
#include <cstdlib>
@@ -22,11 +25,8 @@
#include <memory>
#include <utility>
-#include <fidl/test/llcpp/dirent/c/fidl.h>
-#include <zxtest/zxtest.h>
-
// Interface under test.
-#include <fidl/test/llcpp/dirent/llcpp/fidl.h>
+#include "generated/fidl_llcpp_dirent.h"
// Namespace shorthand for bindings generated code
namespace gen = ::llcpp::fidl::test::llcpp::dirent;
@@ -66,8 +66,7 @@
class Server {
public:
- Server(zx::channel chan)
- : chan_(std::move(chan)), loop_(&kAsyncLoopConfigNoAttachToCurrentThread) {}
+ Server(zx::channel chan) : chan_(std::move(chan)), loop_(&kAsyncLoopConfigNoAttachToCurrentThread) {}
zx_status_t Start() {
zx_status_t status = loop_.StartThread("llcpp_manual_server");
@@ -229,8 +228,7 @@
class ServerBase : public gen::DirEntTestInterface::Interface {
public:
- ServerBase(zx::channel chan)
- : chan_(std::move(chan)), loop_(&kAsyncLoopConfigNoAttachToCurrentThread) {}
+ ServerBase(zx::channel chan) : chan_(std::move(chan)), loop_(&kAsyncLoopConfigNoAttachToCurrentThread) {}
zx_status_t Start() {
zx_status_t status = loop_.StartThread("llcpp_bindings_server");
@@ -515,7 +513,9 @@
fidl::Buffer<gen::DirEntTestInterface::CountNumDirectoriesRequest> request_buffer;
fidl::Buffer<gen::DirEntTestInterface::CountNumDirectoriesResponse> response_buffer;
auto result = client.CountNumDirectories(
- request_buffer.view(), fidl::VectorView<gen::DirEnt>{dirents}, response_buffer.view());
+ request_buffer.view(),
+ fidl::VectorView<gen::DirEnt>{dirents},
+ response_buffer.view());
int64_t expected_num_dir = 0;
for (const auto& dirent : dirents) {
if (dirent.is_dir) {
@@ -753,7 +753,8 @@
}
auto dirents = RandomlyFillDirEnt<kNumDirents>(name.get());
auto status = gen::DirEntTestInterface::SendOnDirentsEvent(
- zx::unowned_channel(server_chan), fidl::VectorView<gen::DirEnt>{dirents});
+ zx::unowned_channel(server_chan),
+ fidl::VectorView<gen::DirEnt>{dirents});
ASSERT_OK(status);
ASSERT_NO_FATAL_FAILURES(AssertReadOnDirentsEvent(std::move(client_chan), dirents));
}
@@ -770,7 +771,8 @@
auto dirents = RandomlyFillDirEnt<kNumDirents>(name.get());
auto buffer = std::make_unique<fidl::Buffer<gen::DirEntTestInterface::OnDirentsResponse>>();
auto status = gen::DirEntTestInterface::SendOnDirentsEvent(
- zx::unowned_channel(server_chan), buffer->view(), fidl::VectorView<gen::DirEnt>{dirents});
+ zx::unowned_channel(server_chan), buffer->view(),
+ fidl::VectorView<gen::DirEnt>{dirents});
ASSERT_OK(status);
ASSERT_NO_FATAL_FAILURES(AssertReadOnDirentsEvent(std::move(client_chan), dirents));
}
diff --git a/zircon/system/utest/fidl-llcpp-interop/gen_llcpp.sh b/zircon/system/utest/fidl-llcpp-interop/gen_llcpp.sh
new file mode 100755
index 0000000..edd98e7
--- /dev/null
+++ b/zircon/system/utest/fidl-llcpp-interop/gen_llcpp.sh
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+
+set -eu
+set -o pipefail
+
+LLCPP_TEST_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+FUCHSIA_DIR="$( echo ${LLCPP_TEST_DIR} | sed -e 's,zircon/system/utest.*$,,' )"
+
+if [ -z ${FUCHSIA_BUILD_DIR+x} ]; then
+ echo "please use fx exec to run this script" 1>&2
+ exit 1
+fi
+
+FIDLC=${FUCHSIA_BUILD_DIR}/host_x64/fidlc
+FIDLGEN=${FUCHSIA_BUILD_DIR}/host_x64/fidlgen_llcpp
+
+if [ ! -x "${FIDLC}" ]; then
+ echo "error: fidlc missing; did you fx clean-build?" 1>&2
+ exit 1
+fi
+
+if [ ! -x "${FIDLGEN}" ]; then
+ echo "error: fidlgen_llcpp missing; did you fx clean-build?" 1>&2
+ exit 1
+fi
+
+cd ${FUCHSIA_DIR}
+
+for src_path in `find "${LLCPP_TEST_DIR}" -name '*.fidl'`; do
+ src_name="$( basename "${src_path}" .fidl )"
+ json_name=${src_name}.json
+
+ # generate the json IR
+ cd ${LLCPP_TEST_DIR}
+ ${FIDLC} --json /tmp/${json_name} \
+ --files ${src_path}
+
+ # generate llcpp bindings
+ ${FIDLGEN} -json /tmp/${json_name} \
+ -header fidl_llcpp_${src_name}.h \
+ -source fidl_llcpp_${src_name}.cc \
+ -include-base .
+
+ # move bindings to the `generated` directory
+ mv fidl_llcpp_${src_name}.h ${LLCPP_TEST_DIR}/generated
+ mv fidl_llcpp_${src_name}.cc ${LLCPP_TEST_DIR}/generated
+
+ # cleanup
+ rm /tmp/${json_name}
+done
diff --git a/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_basictypes.test.cc b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_basictypes.test.cc
new file mode 100644
index 0000000..7e4a67a
--- /dev/null
+++ b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_basictypes.test.cc
@@ -0,0 +1,180 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fidl_llcpp_basictypes.test.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace llcpp {
+namespace basictypes {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kTestInterface_ConsumeSimpleStruct_Ordinal = 0x2b65368b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kTestInterface_ConsumeSimpleStruct_GenOrdinal = 0x2eccc2554e6aae0elu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_basictypes_TestInterfaceConsumeSimpleStructRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_basictypes_TestInterfaceConsumeSimpleStructResponseTable;
+
+} // namespace
+template <>
+TestInterface::ResultOf::ConsumeSimpleStruct_Impl<TestInterface::ConsumeSimpleStructResponse>::ConsumeSimpleStruct_Impl(::zx::unowned_channel _client_end, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConsumeSimpleStructRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ConsumeSimpleStructRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConsumeSimpleStructRequest*>(_write_bytes);
+ _request.arg = std::move(arg);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConsumeSimpleStructRequest));
+ ::fidl::DecodedMessage<ConsumeSimpleStructRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ TestInterface::InPlace::ConsumeSimpleStruct(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+TestInterface::ResultOf::ConsumeSimpleStruct TestInterface::SyncClient::ConsumeSimpleStruct(::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg) {
+ return ResultOf::ConsumeSimpleStruct(::zx::unowned_channel(this->channel_), std::move(arg));
+}
+
+TestInterface::ResultOf::ConsumeSimpleStruct TestInterface::Call::ConsumeSimpleStruct(::zx::unowned_channel _client_end, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg) {
+ return ResultOf::ConsumeSimpleStruct(std::move(_client_end), std::move(arg));
+}
+
+template <>
+TestInterface::UnownedResultOf::ConsumeSimpleStruct_Impl<TestInterface::ConsumeSimpleStructResponse>::ConsumeSimpleStruct_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConsumeSimpleStructRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConsumeSimpleStructResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ memset(_request_buffer.data(), 0, ConsumeSimpleStructRequest::PrimarySize);
+ auto& _request = *reinterpret_cast<ConsumeSimpleStructRequest*>(_request_buffer.data());
+ _request.arg = std::move(arg);
+ _request_buffer.set_actual(sizeof(ConsumeSimpleStructRequest));
+ ::fidl::DecodedMessage<ConsumeSimpleStructRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ TestInterface::InPlace::ConsumeSimpleStruct(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+TestInterface::UnownedResultOf::ConsumeSimpleStruct TestInterface::SyncClient::ConsumeSimpleStruct(::fidl::BytePart _request_buffer, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConsumeSimpleStruct(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(arg), std::move(_response_buffer));
+}
+
+TestInterface::UnownedResultOf::ConsumeSimpleStruct TestInterface::Call::ConsumeSimpleStruct(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConsumeSimpleStruct(std::move(_client_end), std::move(_request_buffer), std::move(arg), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<TestInterface::ConsumeSimpleStructResponse> TestInterface::InPlace::ConsumeSimpleStruct(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConsumeSimpleStructRequest> params, ::fidl::BytePart response_buffer) {
+ TestInterface::SetTransactionHeaderFor::ConsumeSimpleStructRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestInterface::ConsumeSimpleStructResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConsumeSimpleStructRequest, ConsumeSimpleStructResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<TestInterface::ConsumeSimpleStructResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool TestInterface::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kTestInterface_ConsumeSimpleStruct_Ordinal:
+ case kTestInterface_ConsumeSimpleStruct_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConsumeSimpleStructRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ConsumeSimpleStruct(std::move(message->arg),
+ Interface::ConsumeSimpleStructCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool TestInterface::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void TestInterface::Interface::ConsumeSimpleStructCompleterBase::Reply(int32_t status, int32_t field) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConsumeSimpleStructResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConsumeSimpleStructResponse*>(_write_bytes);
+ TestInterface::SetTransactionHeaderFor::ConsumeSimpleStructResponse(
+ ::fidl::DecodedMessage<ConsumeSimpleStructResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConsumeSimpleStructResponse::PrimarySize,
+ ConsumeSimpleStructResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.field = std::move(field);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConsumeSimpleStructResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConsumeSimpleStructResponse>(std::move(_response_bytes)));
+}
+
+void TestInterface::Interface::ConsumeSimpleStructCompleterBase::Reply(::fidl::BytePart _buffer, int32_t status, int32_t field) {
+ if (_buffer.capacity() < ConsumeSimpleStructResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ConsumeSimpleStructResponse*>(_buffer.data());
+ TestInterface::SetTransactionHeaderFor::ConsumeSimpleStructResponse(
+ ::fidl::DecodedMessage<ConsumeSimpleStructResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConsumeSimpleStructResponse::PrimarySize,
+ ConsumeSimpleStructResponse::PrimarySize)));
+ _response.status = std::move(status);
+ _response.field = std::move(field);
+ _buffer.set_actual(sizeof(ConsumeSimpleStructResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConsumeSimpleStructResponse>(std::move(_buffer)));
+}
+
+void TestInterface::Interface::ConsumeSimpleStructCompleterBase::Reply(::fidl::DecodedMessage<ConsumeSimpleStructResponse> params) {
+ TestInterface::SetTransactionHeaderFor::ConsumeSimpleStructResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void TestInterface::SetTransactionHeaderFor::ConsumeSimpleStructRequest(const ::fidl::DecodedMessage<TestInterface::ConsumeSimpleStructRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestInterface_ConsumeSimpleStruct_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void TestInterface::SetTransactionHeaderFor::ConsumeSimpleStructResponse(const ::fidl::DecodedMessage<TestInterface::ConsumeSimpleStructResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kTestInterface_ConsumeSimpleStruct_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace basictypes
+} // namespace llcpp
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
diff --git a/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_basictypes.test.h b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_basictypes.test.h
new file mode 100644
index 0000000..4b84c97
--- /dev/null
+++ b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_basictypes.test.h
@@ -0,0 +1,282 @@
+// 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/eventpair.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace llcpp {
+namespace basictypes {
+
+struct SimpleStruct;
+class TestInterface;
+
+extern "C" const fidl_type_t v1_fidl_test_llcpp_basictypes_SimpleStructTable;
+
+struct SimpleStruct {
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_basictypes_SimpleStructTable;
+ static constexpr uint32_t MaxNumHandles = 21;
+ static constexpr uint32_t PrimarySize = 88;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr bool HasPointer = false;
+
+ int32_t field = {};
+
+ ::zx::eventpair ep = {};
+
+ ::fidl::Array<::fidl::Array<::zx::eventpair, 4>, 5> arr = {};
+};
+
+extern "C" const fidl_type_t v1_fidl_test_llcpp_basictypes_TestInterfaceConsumeSimpleStructRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_basictypes_TestInterfaceConsumeSimpleStructResponseTable;
+
+// Test interface implemented by both C and LLCPP
+class TestInterface final {
+ TestInterface() = delete;
+ public:
+
+ struct ConsumeSimpleStructResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t status;
+ int32_t field;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_basictypes_TestInterfaceConsumeSimpleStructResponseTable;
+ 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 ConsumeSimpleStructRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_basictypes_TestInterfaceConsumeSimpleStructRequestTable;
+ static constexpr uint32_t MaxNumHandles = 21;
+ static constexpr uint32_t PrimarySize = 104;
+ static constexpr uint32_t MaxOutOfLine = 0;
+ static constexpr uint32_t AltPrimarySize = 104;
+ 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 = ConsumeSimpleStructResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class ConsumeSimpleStruct_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ConsumeSimpleStruct_Impl(::zx::unowned_channel _client_end, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg);
+ ~ConsumeSimpleStruct_Impl() = default;
+ ConsumeSimpleStruct_Impl(ConsumeSimpleStruct_Impl&& other) = default;
+ ConsumeSimpleStruct_Impl& operator=(ConsumeSimpleStruct_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 ConsumeSimpleStruct = ConsumeSimpleStruct_Impl<ConsumeSimpleStructResponse>;
+ };
+
+ // 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 ConsumeSimpleStruct_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ConsumeSimpleStruct_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg, ::fidl::BytePart _response_buffer);
+ ~ConsumeSimpleStruct_Impl() = default;
+ ConsumeSimpleStruct_Impl(ConsumeSimpleStruct_Impl&& other) = default;
+ ConsumeSimpleStruct_Impl& operator=(ConsumeSimpleStruct_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 ConsumeSimpleStruct = ConsumeSimpleStruct_Impl<ConsumeSimpleStructResponse>;
+ };
+
+ 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_; }
+
+ // Verifies that all the handles are valid channels, then returns
+ // `ZX_OK` and loops back the field member. Otherwise, returns an error.
+ // Allocates 128 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConsumeSimpleStruct ConsumeSimpleStruct(::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg);
+
+ // Verifies that all the handles are valid channels, then returns
+ // `ZX_OK` and loops back the field member. Otherwise, returns an error.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConsumeSimpleStruct ConsumeSimpleStruct(::fidl::BytePart _request_buffer, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg, ::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:
+
+ // Verifies that all the handles are valid channels, then returns
+ // `ZX_OK` and loops back the field member. Otherwise, returns an error.
+ // Allocates 128 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConsumeSimpleStruct ConsumeSimpleStruct(::zx::unowned_channel _client_end, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg);
+
+ // Verifies that all the handles are valid channels, then returns
+ // `ZX_OK` and loops back the field member. Otherwise, returns an error.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConsumeSimpleStruct ConsumeSimpleStruct(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg, ::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:
+
+ // Verifies that all the handles are valid channels, then returns
+ // `ZX_OK` and loops back the field member. Otherwise, returns an error.
+ static ::fidl::DecodeResult<ConsumeSimpleStructResponse> ConsumeSimpleStruct(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConsumeSimpleStructRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = TestInterface;
+ using _Base = ::fidl::CompleterBase;
+
+ class ConsumeSimpleStructCompleterBase : public _Base {
+ public:
+ void Reply(int32_t status, int32_t field);
+ void Reply(::fidl::BytePart _buffer, int32_t status, int32_t field);
+ void Reply(::fidl::DecodedMessage<ConsumeSimpleStructResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConsumeSimpleStructCompleter = ::fidl::Completer<ConsumeSimpleStructCompleterBase>;
+
+ virtual void ConsumeSimpleStruct(::llcpp::fidl::test::llcpp::basictypes::SimpleStruct arg, ConsumeSimpleStructCompleter::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 ConsumeSimpleStructRequest(const ::fidl::DecodedMessage<TestInterface::ConsumeSimpleStructRequest>& _msg);
+ static void ConsumeSimpleStructResponse(const ::fidl::DecodedMessage<TestInterface::ConsumeSimpleStructResponse>& _msg);
+ };
+};
+
+} // namespace basictypes
+} // namespace llcpp
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::basictypes::SimpleStruct> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fidl::test::llcpp::basictypes::SimpleStruct>);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::basictypes::SimpleStruct, field) == 0);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::basictypes::SimpleStruct, ep) == 4);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::basictypes::SimpleStruct, arr) == 8);
+static_assert(sizeof(::llcpp::fidl::test::llcpp::basictypes::SimpleStruct) == ::llcpp::fidl::test::llcpp::basictypes::SimpleStruct::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructRequest)
+ == ::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructRequest, arg) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructResponse)
+ == ::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructResponse, status) == 16);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::basictypes::TestInterface::ConsumeSimpleStructResponse, field) == 20);
+
+} // namespace fidl
diff --git a/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_controlflow.cc b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_controlflow.cc
new file mode 100644
index 0000000..11f24bf
--- /dev/null
+++ b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_controlflow.cc
@@ -0,0 +1,306 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fidl_llcpp_controlflow.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace llcpp {
+namespace controlflow {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kControlFlow_Shutdown_Ordinal = 0x7d0a313700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControlFlow_Shutdown_GenOrdinal = 0x19770efd3da66572lu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowShutdownRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowShutdownResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControlFlow_NoReplyMustSendAccessDeniedEpitaph_Ordinal = 0x2141b1d000000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControlFlow_NoReplyMustSendAccessDeniedEpitaph_GenOrdinal = 0x2917c62ca2c9424elu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowNoReplyMustSendAccessDeniedEpitaphRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowNoReplyMustSendAccessDeniedEpitaphResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kControlFlow_MustSendAccessDeniedEpitaph_Ordinal = 0x531dcb0700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kControlFlow_MustSendAccessDeniedEpitaph_GenOrdinal = 0x206576ae2ffd5305lu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowMustSendAccessDeniedEpitaphRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowMustSendAccessDeniedEpitaphResponseTable;
+
+} // namespace
+
+ControlFlow::ResultOf::Shutdown_Impl::Shutdown_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ShutdownRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ShutdownRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ShutdownRequest));
+ ::fidl::DecodedMessage<ShutdownRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ ControlFlow::InPlace::Shutdown(std::move(_client_end)));
+}
+
+ControlFlow::ResultOf::Shutdown ControlFlow::SyncClient::Shutdown() {
+ return ResultOf::Shutdown(::zx::unowned_channel(this->channel_));
+}
+
+ControlFlow::ResultOf::Shutdown ControlFlow::Call::Shutdown(::zx::unowned_channel _client_end) {
+ return ResultOf::Shutdown(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError ControlFlow::InPlace::Shutdown(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(ShutdownRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ShutdownRequest> params(std::move(_request_buffer));
+ ControlFlow::SetTransactionHeaderFor::ShutdownRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+
+ControlFlow::ResultOf::NoReplyMustSendAccessDeniedEpitaph_Impl::NoReplyMustSendAccessDeniedEpitaph_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<NoReplyMustSendAccessDeniedEpitaphRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, NoReplyMustSendAccessDeniedEpitaphRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(NoReplyMustSendAccessDeniedEpitaphRequest));
+ ::fidl::DecodedMessage<NoReplyMustSendAccessDeniedEpitaphRequest> _decoded_request(std::move(_request_bytes));
+ Super::operator=(
+ ControlFlow::InPlace::NoReplyMustSendAccessDeniedEpitaph(std::move(_client_end)));
+}
+
+ControlFlow::ResultOf::NoReplyMustSendAccessDeniedEpitaph ControlFlow::SyncClient::NoReplyMustSendAccessDeniedEpitaph() {
+ return ResultOf::NoReplyMustSendAccessDeniedEpitaph(::zx::unowned_channel(this->channel_));
+}
+
+ControlFlow::ResultOf::NoReplyMustSendAccessDeniedEpitaph ControlFlow::Call::NoReplyMustSendAccessDeniedEpitaph(::zx::unowned_channel _client_end) {
+ return ResultOf::NoReplyMustSendAccessDeniedEpitaph(std::move(_client_end));
+}
+
+::fidl::internal::StatusAndError ControlFlow::InPlace::NoReplyMustSendAccessDeniedEpitaph(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _write_num_bytes = sizeof(NoReplyMustSendAccessDeniedEpitaphRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<NoReplyMustSendAccessDeniedEpitaphRequest> params(std::move(_request_buffer));
+ ControlFlow::SetTransactionHeaderFor::NoReplyMustSendAccessDeniedEpitaphRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+template <>
+ControlFlow::ResultOf::MustSendAccessDeniedEpitaph_Impl<ControlFlow::MustSendAccessDeniedEpitaphResponse>::MustSendAccessDeniedEpitaph_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MustSendAccessDeniedEpitaphRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, MustSendAccessDeniedEpitaphRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(MustSendAccessDeniedEpitaphRequest));
+ ::fidl::DecodedMessage<MustSendAccessDeniedEpitaphRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ ControlFlow::InPlace::MustSendAccessDeniedEpitaph(std::move(_client_end), Super::response_buffer()));
+}
+
+ControlFlow::ResultOf::MustSendAccessDeniedEpitaph ControlFlow::SyncClient::MustSendAccessDeniedEpitaph() {
+ return ResultOf::MustSendAccessDeniedEpitaph(::zx::unowned_channel(this->channel_));
+}
+
+ControlFlow::ResultOf::MustSendAccessDeniedEpitaph ControlFlow::Call::MustSendAccessDeniedEpitaph(::zx::unowned_channel _client_end) {
+ return ResultOf::MustSendAccessDeniedEpitaph(std::move(_client_end));
+}
+
+template <>
+ControlFlow::UnownedResultOf::MustSendAccessDeniedEpitaph_Impl<ControlFlow::MustSendAccessDeniedEpitaphResponse>::MustSendAccessDeniedEpitaph_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(MustSendAccessDeniedEpitaphRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, MustSendAccessDeniedEpitaphRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(MustSendAccessDeniedEpitaphRequest));
+ ::fidl::DecodedMessage<MustSendAccessDeniedEpitaphRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ ControlFlow::InPlace::MustSendAccessDeniedEpitaph(std::move(_client_end), std::move(_response_buffer)));
+}
+
+ControlFlow::UnownedResultOf::MustSendAccessDeniedEpitaph ControlFlow::SyncClient::MustSendAccessDeniedEpitaph(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::MustSendAccessDeniedEpitaph(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+ControlFlow::UnownedResultOf::MustSendAccessDeniedEpitaph ControlFlow::Call::MustSendAccessDeniedEpitaph(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::MustSendAccessDeniedEpitaph(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<ControlFlow::MustSendAccessDeniedEpitaphResponse> ControlFlow::InPlace::MustSendAccessDeniedEpitaph(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(MustSendAccessDeniedEpitaphRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<MustSendAccessDeniedEpitaphRequest> params(std::move(_request_buffer));
+ ControlFlow::SetTransactionHeaderFor::MustSendAccessDeniedEpitaphRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ControlFlow::MustSendAccessDeniedEpitaphResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<MustSendAccessDeniedEpitaphRequest, MustSendAccessDeniedEpitaphResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<ControlFlow::MustSendAccessDeniedEpitaphResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool ControlFlow::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kControlFlow_Shutdown_Ordinal:
+ case kControlFlow_Shutdown_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ShutdownRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Shutdown(
+ Interface::ShutdownCompleter::Sync(txn));
+ return true;
+ }
+ case kControlFlow_NoReplyMustSendAccessDeniedEpitaph_Ordinal:
+ case kControlFlow_NoReplyMustSendAccessDeniedEpitaph_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<NoReplyMustSendAccessDeniedEpitaphRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->NoReplyMustSendAccessDeniedEpitaph(
+ Interface::NoReplyMustSendAccessDeniedEpitaphCompleter::Sync(txn));
+ return true;
+ }
+ case kControlFlow_MustSendAccessDeniedEpitaph_Ordinal:
+ case kControlFlow_MustSendAccessDeniedEpitaph_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<MustSendAccessDeniedEpitaphRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->MustSendAccessDeniedEpitaph(
+ Interface::MustSendAccessDeniedEpitaphCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool ControlFlow::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void ControlFlow::Interface::MustSendAccessDeniedEpitaphCompleterBase::Reply(int32_t reply) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<MustSendAccessDeniedEpitaphResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<MustSendAccessDeniedEpitaphResponse*>(_write_bytes);
+ ControlFlow::SetTransactionHeaderFor::MustSendAccessDeniedEpitaphResponse(
+ ::fidl::DecodedMessage<MustSendAccessDeniedEpitaphResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MustSendAccessDeniedEpitaphResponse::PrimarySize,
+ MustSendAccessDeniedEpitaphResponse::PrimarySize)));
+ _response.reply = std::move(reply);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(MustSendAccessDeniedEpitaphResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<MustSendAccessDeniedEpitaphResponse>(std::move(_response_bytes)));
+}
+
+void ControlFlow::Interface::MustSendAccessDeniedEpitaphCompleterBase::Reply(::fidl::BytePart _buffer, int32_t reply) {
+ if (_buffer.capacity() < MustSendAccessDeniedEpitaphResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<MustSendAccessDeniedEpitaphResponse*>(_buffer.data());
+ ControlFlow::SetTransactionHeaderFor::MustSendAccessDeniedEpitaphResponse(
+ ::fidl::DecodedMessage<MustSendAccessDeniedEpitaphResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ MustSendAccessDeniedEpitaphResponse::PrimarySize,
+ MustSendAccessDeniedEpitaphResponse::PrimarySize)));
+ _response.reply = std::move(reply);
+ _buffer.set_actual(sizeof(MustSendAccessDeniedEpitaphResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<MustSendAccessDeniedEpitaphResponse>(std::move(_buffer)));
+}
+
+void ControlFlow::Interface::MustSendAccessDeniedEpitaphCompleterBase::Reply(::fidl::DecodedMessage<MustSendAccessDeniedEpitaphResponse> params) {
+ ControlFlow::SetTransactionHeaderFor::MustSendAccessDeniedEpitaphResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void ControlFlow::SetTransactionHeaderFor::ShutdownRequest(const ::fidl::DecodedMessage<ControlFlow::ShutdownRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControlFlow_Shutdown_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ControlFlow::SetTransactionHeaderFor::NoReplyMustSendAccessDeniedEpitaphRequest(const ::fidl::DecodedMessage<ControlFlow::NoReplyMustSendAccessDeniedEpitaphRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControlFlow_NoReplyMustSendAccessDeniedEpitaph_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void ControlFlow::SetTransactionHeaderFor::MustSendAccessDeniedEpitaphRequest(const ::fidl::DecodedMessage<ControlFlow::MustSendAccessDeniedEpitaphRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControlFlow_MustSendAccessDeniedEpitaph_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void ControlFlow::SetTransactionHeaderFor::MustSendAccessDeniedEpitaphResponse(const ::fidl::DecodedMessage<ControlFlow::MustSendAccessDeniedEpitaphResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kControlFlow_MustSendAccessDeniedEpitaph_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace controlflow
+} // namespace llcpp
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
diff --git a/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_controlflow.h b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_controlflow.h
new file mode 100644
index 0000000..aa37e9c
--- /dev/null
+++ b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_controlflow.h
@@ -0,0 +1,339 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace llcpp {
+namespace controlflow {
+
+class ControlFlow;
+
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowShutdownRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowShutdownResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowNoReplyMustSendAccessDeniedEpitaphRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowNoReplyMustSendAccessDeniedEpitaphResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowMustSendAccessDeniedEpitaphRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_controlflow_ControlFlowMustSendAccessDeniedEpitaphResponseTable;
+
+// Interface for testing shutdown/epitaphs etc.
+class ControlFlow final {
+ ControlFlow() = delete;
+ public:
+
+ using ShutdownRequest = ::fidl::AnyZeroArgMessage;
+
+ using NoReplyMustSendAccessDeniedEpitaphRequest = ::fidl::AnyZeroArgMessage;
+
+ struct MustSendAccessDeniedEpitaphResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t reply;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_controlflow_ControlFlowMustSendAccessDeniedEpitaphResponseTable;
+ 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 MustSendAccessDeniedEpitaphRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ class Shutdown_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Shutdown_Impl(::zx::unowned_channel _client_end);
+ ~Shutdown_Impl() = default;
+ Shutdown_Impl(Shutdown_Impl&& other) = default;
+ Shutdown_Impl& operator=(Shutdown_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class NoReplyMustSendAccessDeniedEpitaph_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ NoReplyMustSendAccessDeniedEpitaph_Impl(::zx::unowned_channel _client_end);
+ ~NoReplyMustSendAccessDeniedEpitaph_Impl() = default;
+ NoReplyMustSendAccessDeniedEpitaph_Impl(NoReplyMustSendAccessDeniedEpitaph_Impl&& other) = default;
+ NoReplyMustSendAccessDeniedEpitaph_Impl& operator=(NoReplyMustSendAccessDeniedEpitaph_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class MustSendAccessDeniedEpitaph_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ MustSendAccessDeniedEpitaph_Impl(::zx::unowned_channel _client_end);
+ ~MustSendAccessDeniedEpitaph_Impl() = default;
+ MustSendAccessDeniedEpitaph_Impl(MustSendAccessDeniedEpitaph_Impl&& other) = default;
+ MustSendAccessDeniedEpitaph_Impl& operator=(MustSendAccessDeniedEpitaph_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 Shutdown = Shutdown_Impl;
+ using NoReplyMustSendAccessDeniedEpitaph = NoReplyMustSendAccessDeniedEpitaph_Impl;
+ using MustSendAccessDeniedEpitaph = MustSendAccessDeniedEpitaph_Impl<MustSendAccessDeniedEpitaphResponse>;
+ };
+
+ // 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:
+ class Shutdown_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ Shutdown_Impl(::zx::unowned_channel _client_end);
+ ~Shutdown_Impl() = default;
+ Shutdown_Impl(Shutdown_Impl&& other) = default;
+ Shutdown_Impl& operator=(Shutdown_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ class NoReplyMustSendAccessDeniedEpitaph_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ NoReplyMustSendAccessDeniedEpitaph_Impl(::zx::unowned_channel _client_end);
+ ~NoReplyMustSendAccessDeniedEpitaph_Impl() = default;
+ NoReplyMustSendAccessDeniedEpitaph_Impl(NoReplyMustSendAccessDeniedEpitaph_Impl&& other) = default;
+ NoReplyMustSendAccessDeniedEpitaph_Impl& operator=(NoReplyMustSendAccessDeniedEpitaph_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+ template <typename ResponseType>
+ class MustSendAccessDeniedEpitaph_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ MustSendAccessDeniedEpitaph_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~MustSendAccessDeniedEpitaph_Impl() = default;
+ MustSendAccessDeniedEpitaph_Impl(MustSendAccessDeniedEpitaph_Impl&& other) = default;
+ MustSendAccessDeniedEpitaph_Impl& operator=(MustSendAccessDeniedEpitaph_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 Shutdown = Shutdown_Impl;
+ using NoReplyMustSendAccessDeniedEpitaph = NoReplyMustSendAccessDeniedEpitaph_Impl;
+ using MustSendAccessDeniedEpitaph = MustSendAccessDeniedEpitaph_Impl<MustSendAccessDeniedEpitaphResponse>;
+ };
+
+ 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_; }
+
+ // Shutdown the server without a reply.
+ // The server should unbind the channel from the dispatch loop, closing it.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Shutdown Shutdown();
+
+
+ // Calling this method generates no reply and a epitaph with error set to
+ // `ZX_ERR_ACCESS_DENIED`. The channel will then be closed.
+ // This tests sending an epitaph from the one-way method call handler.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::NoReplyMustSendAccessDeniedEpitaph NoReplyMustSendAccessDeniedEpitaph();
+
+
+ // Despite the fact that a reply was defined in the method signature,
+ // Calling this method generates no reply and a epitaph with error set to
+ // `ZX_ERR_ACCESS_DENIED`. The channel will then be closed.
+ // This tests sending an epitaph from a normal (two-way) method call handler.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::MustSendAccessDeniedEpitaph MustSendAccessDeniedEpitaph();
+
+ // Despite the fact that a reply was defined in the method signature,
+ // Calling this method generates no reply and a epitaph with error set to
+ // `ZX_ERR_ACCESS_DENIED`. The channel will then be closed.
+ // This tests sending an epitaph from a normal (two-way) method call handler.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::MustSendAccessDeniedEpitaph MustSendAccessDeniedEpitaph(::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:
+
+ // Shutdown the server without a reply.
+ // The server should unbind the channel from the dispatch loop, closing it.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Shutdown Shutdown(::zx::unowned_channel _client_end);
+
+
+ // Calling this method generates no reply and a epitaph with error set to
+ // `ZX_ERR_ACCESS_DENIED`. The channel will then be closed.
+ // This tests sending an epitaph from the one-way method call handler.
+ // Allocates 16 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::NoReplyMustSendAccessDeniedEpitaph NoReplyMustSendAccessDeniedEpitaph(::zx::unowned_channel _client_end);
+
+
+ // Despite the fact that a reply was defined in the method signature,
+ // Calling this method generates no reply and a epitaph with error set to
+ // `ZX_ERR_ACCESS_DENIED`. The channel will then be closed.
+ // This tests sending an epitaph from a normal (two-way) method call handler.
+ // Allocates 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::MustSendAccessDeniedEpitaph MustSendAccessDeniedEpitaph(::zx::unowned_channel _client_end);
+
+ // Despite the fact that a reply was defined in the method signature,
+ // Calling this method generates no reply and a epitaph with error set to
+ // `ZX_ERR_ACCESS_DENIED`. The channel will then be closed.
+ // This tests sending an epitaph from a normal (two-way) method call handler.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::MustSendAccessDeniedEpitaph MustSendAccessDeniedEpitaph(::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:
+
+ // Shutdown the server without a reply.
+ // The server should unbind the channel from the dispatch loop, closing it.
+ static ::fidl::internal::StatusAndError Shutdown(::zx::unowned_channel _client_end);
+
+ // Calling this method generates no reply and a epitaph with error set to
+ // `ZX_ERR_ACCESS_DENIED`. The channel will then be closed.
+ // This tests sending an epitaph from the one-way method call handler.
+ static ::fidl::internal::StatusAndError NoReplyMustSendAccessDeniedEpitaph(::zx::unowned_channel _client_end);
+
+ // Despite the fact that a reply was defined in the method signature,
+ // Calling this method generates no reply and a epitaph with error set to
+ // `ZX_ERR_ACCESS_DENIED`. The channel will then be closed.
+ // This tests sending an epitaph from a normal (two-way) method call handler.
+ static ::fidl::DecodeResult<MustSendAccessDeniedEpitaphResponse> MustSendAccessDeniedEpitaph(::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 = ControlFlow;
+ using _Base = ::fidl::CompleterBase;
+
+ using ShutdownCompleter = ::fidl::Completer<>;
+
+ virtual void Shutdown(ShutdownCompleter::Sync _completer) = 0;
+
+ using NoReplyMustSendAccessDeniedEpitaphCompleter = ::fidl::Completer<>;
+
+ virtual void NoReplyMustSendAccessDeniedEpitaph(NoReplyMustSendAccessDeniedEpitaphCompleter::Sync _completer) = 0;
+
+ class MustSendAccessDeniedEpitaphCompleterBase : public _Base {
+ public:
+ void Reply(int32_t reply);
+ void Reply(::fidl::BytePart _buffer, int32_t reply);
+ void Reply(::fidl::DecodedMessage<MustSendAccessDeniedEpitaphResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using MustSendAccessDeniedEpitaphCompleter = ::fidl::Completer<MustSendAccessDeniedEpitaphCompleterBase>;
+
+ virtual void MustSendAccessDeniedEpitaph(MustSendAccessDeniedEpitaphCompleter::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 ShutdownRequest(const ::fidl::DecodedMessage<ControlFlow::ShutdownRequest>& _msg);
+ static void NoReplyMustSendAccessDeniedEpitaphRequest(const ::fidl::DecodedMessage<ControlFlow::NoReplyMustSendAccessDeniedEpitaphRequest>& _msg);
+ static void MustSendAccessDeniedEpitaphRequest(const ::fidl::DecodedMessage<ControlFlow::MustSendAccessDeniedEpitaphRequest>& _msg);
+ static void MustSendAccessDeniedEpitaphResponse(const ::fidl::DecodedMessage<ControlFlow::MustSendAccessDeniedEpitaphResponse>& _msg);
+ };
+};
+
+} // namespace controlflow
+} // namespace llcpp
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::controlflow::ControlFlow::MustSendAccessDeniedEpitaphResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::controlflow::ControlFlow::MustSendAccessDeniedEpitaphResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::controlflow::ControlFlow::MustSendAccessDeniedEpitaphResponse)
+ == ::llcpp::fidl::test::llcpp::controlflow::ControlFlow::MustSendAccessDeniedEpitaphResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::controlflow::ControlFlow::MustSendAccessDeniedEpitaphResponse, reply) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_dirent.cc b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_dirent.cc
new file mode 100644
index 0000000..5431144
--- /dev/null
+++ b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_dirent.cc
@@ -0,0 +1,650 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fidl_llcpp_dirent.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace llcpp {
+namespace dirent {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_CountNumDirectories_Ordinal = 0x6915d08800000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_CountNumDirectories_GenOrdinal = 0x331f16100bcf01a1lu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceCountNumDirectoriesRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceCountNumDirectoriesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_ReadDir_Ordinal = 0x52407b00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_ReadDir_GenOrdinal = 0x1b5e15bc80c7cf42lu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceReadDirRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceReadDirResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_ConsumeDirectories_Ordinal = 0x19655c0700000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_ConsumeDirectories_GenOrdinal = 0x5d25ec8ecff39cd9lu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceConsumeDirectoriesRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceConsumeDirectoriesResponseTable;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_OnDirents_Ordinal = 0x4c81d6ba00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_OnDirents_GenOrdinal = 0x7a75e26a45782c25lu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOnDirentsRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOnDirentsEventTable;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_OneWayDirents_Ordinal = 0x6beae37500000000lu;
+[[maybe_unused]]
+constexpr uint64_t kDirEntTestInterface_OneWayDirents_GenOrdinal = 0x3b04d61f058a9043lu;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOneWayDirentsRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOneWayDirentsResponseTable;
+
+} // namespace
+template <>
+DirEntTestInterface::ResultOf::CountNumDirectories_Impl<DirEntTestInterface::CountNumDirectoriesResponse>::CountNumDirectories_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CountNumDirectoriesRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ CountNumDirectoriesRequest _request = {};
+ _request.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CountNumDirectoriesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirEntTestInterface::InPlace::CountNumDirectories(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirEntTestInterface::ResultOf::CountNumDirectories DirEntTestInterface::SyncClient::CountNumDirectories(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ return ResultOf::CountNumDirectories(::zx::unowned_channel(this->channel_), std::move(dirents));
+}
+
+DirEntTestInterface::ResultOf::CountNumDirectories DirEntTestInterface::Call::CountNumDirectories(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ return ResultOf::CountNumDirectories(std::move(_client_end), std::move(dirents));
+}
+
+template <>
+DirEntTestInterface::UnownedResultOf::CountNumDirectories_Impl<DirEntTestInterface::CountNumDirectoriesResponse>::CountNumDirectories_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < CountNumDirectoriesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<CountNumDirectoriesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ CountNumDirectoriesRequest _request = {};
+ _request.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<CountNumDirectoriesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirEntTestInterface::InPlace::CountNumDirectories(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirEntTestInterface::UnownedResultOf::CountNumDirectories DirEntTestInterface::SyncClient::CountNumDirectories(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CountNumDirectories(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(dirents), std::move(_response_buffer));
+}
+
+DirEntTestInterface::UnownedResultOf::CountNumDirectories DirEntTestInterface::Call::CountNumDirectories(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::CountNumDirectories(std::move(_client_end), std::move(_request_buffer), std::move(dirents), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirEntTestInterface::CountNumDirectoriesResponse> DirEntTestInterface::InPlace::CountNumDirectories(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CountNumDirectoriesRequest> params, ::fidl::BytePart response_buffer) {
+ DirEntTestInterface::SetTransactionHeaderFor::CountNumDirectoriesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirEntTestInterface::CountNumDirectoriesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<CountNumDirectoriesRequest, CountNumDirectoriesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirEntTestInterface::CountNumDirectoriesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirEntTestInterface::ResultOf::ReadDir_Impl<DirEntTestInterface::ReadDirResponse>::ReadDir_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ReadDirRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ReadDirRequest));
+ ::fidl::DecodedMessage<ReadDirRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ DirEntTestInterface::InPlace::ReadDir(std::move(_client_end), Super::response_buffer()));
+}
+
+DirEntTestInterface::ResultOf::ReadDir DirEntTestInterface::SyncClient::ReadDir() {
+ return ResultOf::ReadDir(::zx::unowned_channel(this->channel_));
+}
+
+DirEntTestInterface::ResultOf::ReadDir DirEntTestInterface::Call::ReadDir(::zx::unowned_channel _client_end) {
+ return ResultOf::ReadDir(std::move(_client_end));
+}
+
+template <>
+DirEntTestInterface::UnownedResultOf::ReadDir_Impl<DirEntTestInterface::ReadDirResponse>::ReadDir_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ReadDirRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ReadDirRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ReadDirRequest));
+ ::fidl::DecodedMessage<ReadDirRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ DirEntTestInterface::InPlace::ReadDir(std::move(_client_end), std::move(_response_buffer)));
+}
+
+DirEntTestInterface::UnownedResultOf::ReadDir DirEntTestInterface::SyncClient::ReadDir(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadDir(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+DirEntTestInterface::UnownedResultOf::ReadDir DirEntTestInterface::Call::ReadDir(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ReadDir(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirEntTestInterface::ReadDirResponse> DirEntTestInterface::InPlace::ReadDir(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ReadDirRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ReadDirRequest> params(std::move(_request_buffer));
+ DirEntTestInterface::SetTransactionHeaderFor::ReadDirRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirEntTestInterface::ReadDirResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ReadDirRequest, ReadDirResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirEntTestInterface::ReadDirResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+template <>
+DirEntTestInterface::ResultOf::ConsumeDirectories_Impl<DirEntTestInterface::ConsumeDirectoriesResponse>::ConsumeDirectories_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConsumeDirectoriesRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ ConsumeDirectoriesRequest _request = {};
+ _request.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConsumeDirectoriesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirEntTestInterface::InPlace::ConsumeDirectories(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+DirEntTestInterface::ResultOf::ConsumeDirectories DirEntTestInterface::SyncClient::ConsumeDirectories(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ return ResultOf::ConsumeDirectories(::zx::unowned_channel(this->channel_), std::move(dirents));
+}
+
+DirEntTestInterface::ResultOf::ConsumeDirectories DirEntTestInterface::Call::ConsumeDirectories(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ return ResultOf::ConsumeDirectories(std::move(_client_end), std::move(dirents));
+}
+
+template <>
+DirEntTestInterface::UnownedResultOf::ConsumeDirectories_Impl<DirEntTestInterface::ConsumeDirectoriesResponse>::ConsumeDirectories_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < ConsumeDirectoriesRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<ConsumeDirectoriesResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ ConsumeDirectoriesRequest _request = {};
+ _request.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<ConsumeDirectoriesRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ DirEntTestInterface::InPlace::ConsumeDirectories(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+DirEntTestInterface::UnownedResultOf::ConsumeDirectories DirEntTestInterface::SyncClient::ConsumeDirectories(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConsumeDirectories(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(dirents), std::move(_response_buffer));
+}
+
+DirEntTestInterface::UnownedResultOf::ConsumeDirectories DirEntTestInterface::Call::ConsumeDirectories(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::ConsumeDirectories(std::move(_client_end), std::move(_request_buffer), std::move(dirents), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<DirEntTestInterface::ConsumeDirectoriesResponse> DirEntTestInterface::InPlace::ConsumeDirectories(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConsumeDirectoriesRequest> params, ::fidl::BytePart response_buffer) {
+ DirEntTestInterface::SetTransactionHeaderFor::ConsumeDirectoriesRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirEntTestInterface::ConsumeDirectoriesResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ConsumeDirectoriesRequest, ConsumeDirectoriesResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<DirEntTestInterface::ConsumeDirectoriesResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+DirEntTestInterface::ResultOf::OneWayDirents_Impl::OneWayDirents_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OneWayDirentsRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ OneWayDirentsRequest _request = {};
+ _request.dirents = std::move(dirents);
+ _request.ep = std::move(ep);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OneWayDirentsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DirEntTestInterface::InPlace::OneWayDirents(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DirEntTestInterface::ResultOf::OneWayDirents DirEntTestInterface::SyncClient::OneWayDirents(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep) {
+ return ResultOf::OneWayDirents(::zx::unowned_channel(this->channel_), std::move(dirents), std::move(ep));
+}
+
+DirEntTestInterface::ResultOf::OneWayDirents DirEntTestInterface::Call::OneWayDirents(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep) {
+ return ResultOf::OneWayDirents(std::move(_client_end), std::move(dirents), std::move(ep));
+}
+
+
+DirEntTestInterface::UnownedResultOf::OneWayDirents_Impl::OneWayDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep) {
+ if (_request_buffer.capacity() < OneWayDirentsRequest::PrimarySize) {
+ Super::status_ = ZX_ERR_BUFFER_TOO_SMALL;
+ Super::error_ = ::fidl::internal::kErrorRequestBufferTooSmall;
+ return;
+ }
+ OneWayDirentsRequest _request = {};
+ _request.dirents = std::move(dirents);
+ _request.ep = std::move(ep);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<OneWayDirentsRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::operator=(
+ DirEntTestInterface::InPlace::OneWayDirents(std::move(_client_end), std::move(_decoded_request)));
+}
+
+DirEntTestInterface::UnownedResultOf::OneWayDirents DirEntTestInterface::SyncClient::OneWayDirents(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep) {
+ return UnownedResultOf::OneWayDirents(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(dirents), std::move(ep));
+}
+
+DirEntTestInterface::UnownedResultOf::OneWayDirents DirEntTestInterface::Call::OneWayDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep) {
+ return UnownedResultOf::OneWayDirents(std::move(_client_end), std::move(_request_buffer), std::move(dirents), std::move(ep));
+}
+
+::fidl::internal::StatusAndError DirEntTestInterface::InPlace::OneWayDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OneWayDirentsRequest> params) {
+ DirEntTestInterface::SetTransactionHeaderFor::OneWayDirentsRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::internal::StatusAndError::FromFailure(
+ std::move(_encode_request_result));
+ }
+ zx_status_t _write_status =
+ ::fidl::Write(std::move(_client_end), std::move(_encode_request_result.message));
+ if (_write_status != ZX_OK) {
+ return ::fidl::internal::StatusAndError(_write_status, ::fidl::internal::kErrorWriteFailed);
+ } else {
+ return ::fidl::internal::StatusAndError(ZX_OK, nullptr);
+ }
+}
+
+zx_status_t DirEntTestInterface::SyncClient::HandleEvents(DirEntTestInterface::EventHandlers handlers) {
+ return DirEntTestInterface::Call::HandleEvents(::zx::unowned_channel(channel_), std::move(handlers));
+}
+
+zx_status_t DirEntTestInterface::Call::HandleEvents(::zx::unowned_channel client_end, DirEntTestInterface::EventHandlers handlers) {
+ zx_status_t status = client_end->wait_one(ZX_CHANNEL_READABLE | ZX_CHANNEL_PEER_CLOSED,
+ ::zx::time::infinite(),
+ nullptr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ constexpr uint32_t kReadAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (::fidl::internal::ClampedMessageSize<OnDirentsResponse, ::fidl::MessageDirection::kReceiving>() >= x) {
+ x = ::fidl::internal::ClampedMessageSize<OnDirentsResponse, ::fidl::MessageDirection::kReceiving>();
+ }
+ return x;
+ })();
+ constexpr uint32_t kHandleAllocSize = ([]() constexpr {
+ uint32_t x = 0;
+ if (OnDirentsResponse::MaxNumHandles >= x) {
+ x = OnDirentsResponse::MaxNumHandles;
+ }
+ if (x > ZX_CHANNEL_MAX_MSG_HANDLES) {
+ x = ZX_CHANNEL_MAX_MSG_HANDLES;
+ }
+ return x;
+ })();
+ ::fidl::internal::ByteStorage<kReadAllocSize> read_storage;
+ uint8_t* read_bytes = read_storage.buffer().data();
+ zx_handle_t read_handles[kHandleAllocSize];
+ uint32_t actual_bytes;
+ uint32_t actual_handles;
+ status = client_end->read(ZX_CHANNEL_READ_MAY_DISCARD,
+ read_bytes, read_handles,
+ kReadAllocSize, kHandleAllocSize,
+ &actual_bytes, &actual_handles);
+ if (status == ZX_ERR_BUFFER_TOO_SMALL) {
+ // Message size is unexpectedly larger than calculated.
+ // This can only be due to a newer version of the protocol defining a new event,
+ // whose size exceeds the maximum of known events in the current protocol.
+ return handlers.unknown();
+ }
+ if (status != ZX_OK) {
+ return status;
+ }
+ if (actual_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(read_handles, actual_handles);
+ return ZX_ERR_INVALID_ARGS;
+ }
+ auto msg = fidl_msg_t {
+ .bytes = read_bytes,
+ .handles = read_handles,
+ .num_bytes = actual_bytes,
+ .num_handles = actual_handles
+ };
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg.bytes);
+ status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ return status;
+ }
+ switch (hdr->ordinal) {
+ case kDirEntTestInterface_OnDirents_Ordinal:
+ case kDirEntTestInterface_OnDirents_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OnDirentsResponse>(&msg);
+ if (result.status != ZX_OK) {
+ return result.status;
+ }
+ auto message = result.message.message();
+ return handlers.on_dirents(std::move(message->dirents));
+ }
+ default:
+ zx_handle_close_many(read_handles, actual_handles);
+ return handlers.unknown();
+ }
+}
+
+bool DirEntTestInterface::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kDirEntTestInterface_CountNumDirectories_Ordinal:
+ case kDirEntTestInterface_CountNumDirectories_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<CountNumDirectoriesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->CountNumDirectories(std::move(message->dirents),
+ Interface::CountNumDirectoriesCompleter::Sync(txn));
+ return true;
+ }
+ case kDirEntTestInterface_ReadDir_Ordinal:
+ case kDirEntTestInterface_ReadDir_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ReadDirRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->ReadDir(
+ Interface::ReadDirCompleter::Sync(txn));
+ return true;
+ }
+ case kDirEntTestInterface_ConsumeDirectories_Ordinal:
+ case kDirEntTestInterface_ConsumeDirectories_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ConsumeDirectoriesRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->ConsumeDirectories(std::move(message->dirents),
+ Interface::ConsumeDirectoriesCompleter::Sync(txn));
+ return true;
+ }
+ case kDirEntTestInterface_OneWayDirents_Ordinal:
+ case kDirEntTestInterface_OneWayDirents_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<OneWayDirentsRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->OneWayDirents(std::move(message->dirents), std::move(message->ep),
+ Interface::OneWayDirentsCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool DirEntTestInterface::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void DirEntTestInterface::Interface::CountNumDirectoriesCompleterBase::Reply(int64_t num_dir) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<CountNumDirectoriesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<CountNumDirectoriesResponse*>(_write_bytes);
+ DirEntTestInterface::SetTransactionHeaderFor::CountNumDirectoriesResponse(
+ ::fidl::DecodedMessage<CountNumDirectoriesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CountNumDirectoriesResponse::PrimarySize,
+ CountNumDirectoriesResponse::PrimarySize)));
+ _response.num_dir = std::move(num_dir);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(CountNumDirectoriesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CountNumDirectoriesResponse>(std::move(_response_bytes)));
+}
+
+void DirEntTestInterface::Interface::CountNumDirectoriesCompleterBase::Reply(::fidl::BytePart _buffer, int64_t num_dir) {
+ if (_buffer.capacity() < CountNumDirectoriesResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<CountNumDirectoriesResponse*>(_buffer.data());
+ DirEntTestInterface::SetTransactionHeaderFor::CountNumDirectoriesResponse(
+ ::fidl::DecodedMessage<CountNumDirectoriesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ CountNumDirectoriesResponse::PrimarySize,
+ CountNumDirectoriesResponse::PrimarySize)));
+ _response.num_dir = std::move(num_dir);
+ _buffer.set_actual(sizeof(CountNumDirectoriesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<CountNumDirectoriesResponse>(std::move(_buffer)));
+}
+
+void DirEntTestInterface::Interface::CountNumDirectoriesCompleterBase::Reply(::fidl::DecodedMessage<CountNumDirectoriesResponse> params) {
+ DirEntTestInterface::SetTransactionHeaderFor::CountNumDirectoriesResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirEntTestInterface::Interface::ReadDirCompleterBase::Reply(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ReadDirResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize];
+ ReadDirResponse _response = {};
+ DirEntTestInterface::SetTransactionHeaderFor::ReadDirResponse(
+ ::fidl::DecodedMessage<ReadDirResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDirResponse::PrimarySize,
+ ReadDirResponse::PrimarySize)));
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirEntTestInterface::Interface::ReadDirCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ if (_buffer.capacity() < ReadDirResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ ReadDirResponse _response = {};
+ DirEntTestInterface::SetTransactionHeaderFor::ReadDirResponse(
+ ::fidl::DecodedMessage<ReadDirResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ReadDirResponse::PrimarySize,
+ ReadDirResponse::PrimarySize)));
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void DirEntTestInterface::Interface::ReadDirCompleterBase::Reply(::fidl::DecodedMessage<ReadDirResponse> params) {
+ DirEntTestInterface::SetTransactionHeaderFor::ReadDirResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+void DirEntTestInterface::Interface::ConsumeDirectoriesCompleterBase::Reply() {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ConsumeDirectoriesResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ConsumeDirectoriesResponse*>(_write_bytes);
+ DirEntTestInterface::SetTransactionHeaderFor::ConsumeDirectoriesResponse(
+ ::fidl::DecodedMessage<ConsumeDirectoriesResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ConsumeDirectoriesResponse::PrimarySize,
+ ConsumeDirectoriesResponse::PrimarySize)));
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ConsumeDirectoriesResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ConsumeDirectoriesResponse>(std::move(_response_bytes)));
+}
+
+
+zx_status_t DirEntTestInterface::SendOnDirentsEvent(::zx::unowned_channel _chan, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<OnDirentsResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ OnDirentsResponse _response = {};
+ DirEntTestInterface::SetTransactionHeaderFor::OnDirentsResponse(
+ ::fidl::DecodedMessage<OnDirentsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnDirentsResponse::PrimarySize,
+ OnDirentsResponse::PrimarySize)));
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t DirEntTestInterface::SendOnDirentsEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents) {
+ if (_buffer.capacity() < OnDirentsResponse::PrimarySize) {
+ return ZX_ERR_BUFFER_TOO_SMALL;
+ }
+ OnDirentsResponse _response = {};
+ DirEntTestInterface::SetTransactionHeaderFor::OnDirentsResponse(
+ ::fidl::DecodedMessage<OnDirentsResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ OnDirentsResponse::PrimarySize,
+ OnDirentsResponse::PrimarySize)));
+ _response.dirents = std::move(dirents);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ return _linearize_result.status;
+ }
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(_linearize_result.message));
+}
+
+zx_status_t DirEntTestInterface::SendOnDirentsEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnDirentsResponse> params) {
+ DirEntTestInterface::SetTransactionHeaderFor::OnDirentsResponse(params);
+ return ::fidl::Write(::zx::unowned_channel(_chan), std::move(params));
+}
+
+
+
+void DirEntTestInterface::SetTransactionHeaderFor::CountNumDirectoriesRequest(const ::fidl::DecodedMessage<DirEntTestInterface::CountNumDirectoriesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirEntTestInterface_CountNumDirectories_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirEntTestInterface::SetTransactionHeaderFor::CountNumDirectoriesResponse(const ::fidl::DecodedMessage<DirEntTestInterface::CountNumDirectoriesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirEntTestInterface_CountNumDirectories_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirEntTestInterface::SetTransactionHeaderFor::ReadDirRequest(const ::fidl::DecodedMessage<DirEntTestInterface::ReadDirRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirEntTestInterface_ReadDir_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirEntTestInterface::SetTransactionHeaderFor::ReadDirResponse(const ::fidl::DecodedMessage<DirEntTestInterface::ReadDirResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirEntTestInterface_ReadDir_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirEntTestInterface::SetTransactionHeaderFor::ConsumeDirectoriesRequest(const ::fidl::DecodedMessage<DirEntTestInterface::ConsumeDirectoriesRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirEntTestInterface_ConsumeDirectories_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void DirEntTestInterface::SetTransactionHeaderFor::ConsumeDirectoriesResponse(const ::fidl::DecodedMessage<DirEntTestInterface::ConsumeDirectoriesResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirEntTestInterface_ConsumeDirectories_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirEntTestInterface::SetTransactionHeaderFor::OnDirentsResponse(const ::fidl::DecodedMessage<DirEntTestInterface::OnDirentsResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirEntTestInterface_OnDirents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+void DirEntTestInterface::SetTransactionHeaderFor::OneWayDirentsRequest(const ::fidl::DecodedMessage<DirEntTestInterface::OneWayDirentsRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kDirEntTestInterface_OneWayDirents_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace dirent
+} // namespace llcpp
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
diff --git a/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_dirent.h b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_dirent.h
new file mode 100644
index 0000000..f2d55d4
--- /dev/null
+++ b/zircon/system/utest/fidl-llcpp-interop/generated/fidl_llcpp_dirent.h
@@ -0,0 +1,612 @@
+// 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/eventpair.h>
+#include <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace llcpp {
+namespace dirent {
+
+struct DirEnt;
+class DirEntTestInterface;
+
+constexpr uint32_t TEST_MAX_PATH = 10u;
+
+constexpr uint32_t SMALL_DIR_VECTOR_SIZE = 3u;
+
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTable;
+
+// Fake dirent structure to exercise linearization codepaths.
+struct DirEnt {
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_dirent_DirEntTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ [[maybe_unused]]
+ static constexpr uint32_t MaxOutOfLine = 16;
+ static constexpr bool HasPointer = true;
+
+ bool is_dir = {};
+
+ ::fidl::StringView name = {};
+
+ int32_t some_flags = {};
+};
+
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceCountNumDirectoriesRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceCountNumDirectoriesResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceReadDirRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceReadDirResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceConsumeDirectoriesRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceConsumeDirectoriesResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOnDirentsRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOnDirentsEventTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOneWayDirentsRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOneWayDirentsResponseTable;
+
+// Test interface implemented by LLCPP, with a manually written server,
+// since types with more than one level of indirections are not handled by the C binding.
+class DirEntTestInterface final {
+ DirEntTestInterface() = delete;
+ public:
+
+ struct CountNumDirectoriesResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int64_t num_dir;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_dirent_DirEntTestInterfaceCountNumDirectoriesResponseTable;
+ 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 CountNumDirectoriesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_dirent_DirEntTestInterfaceCountNumDirectoriesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 48000;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 48000;
+ 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 = CountNumDirectoriesResponse;
+ };
+
+ struct ReadDirResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_dirent_DirEntTestInterfaceReadDirResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 144;
+ 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 ReadDirRequest = ::fidl::AnyZeroArgMessage;
+
+ using ConsumeDirectoriesResponse = ::fidl::AnyZeroArgMessage;
+ struct ConsumeDirectoriesRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_dirent_DirEntTestInterfaceConsumeDirectoriesRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 144;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 144;
+ 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;
+ };
+
+ struct OnDirentsResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOnDirentsEventTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 48000;
+ 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 OneWayDirentsRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents;
+ ::zx::eventpair ep;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_llcpp_dirent_DirEntTestInterfaceOneWayDirentsRequestTable;
+ static constexpr uint32_t MaxNumHandles = 1;
+ static constexpr uint32_t PrimarySize = 40;
+ static constexpr uint32_t MaxOutOfLine = 48000;
+ static constexpr uint32_t AltPrimarySize = 40;
+ static constexpr uint32_t AltMaxOutOfLine = 48000;
+ 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;
+ };
+
+
+ struct EventHandlers {
+ // Event
+ fit::callback<zx_status_t(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents)> on_dirents;
+
+ // Fallback handler when an unknown ordinal is received.
+ // Caller may put custom error handling logic here.
+ fit::callback<zx_status_t()> unknown;
+ };
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class CountNumDirectories_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ CountNumDirectories_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+ ~CountNumDirectories_Impl() = default;
+ CountNumDirectories_Impl(CountNumDirectories_Impl&& other) = default;
+ CountNumDirectories_Impl& operator=(CountNumDirectories_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 ReadDir_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ReadDir_Impl(::zx::unowned_channel _client_end);
+ ~ReadDir_Impl() = default;
+ ReadDir_Impl(ReadDir_Impl&& other) = default;
+ ReadDir_Impl& operator=(ReadDir_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 ConsumeDirectories_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ ConsumeDirectories_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+ ~ConsumeDirectories_Impl() = default;
+ ConsumeDirectories_Impl(ConsumeDirectories_Impl&& other) = default;
+ ConsumeDirectories_Impl& operator=(ConsumeDirectories_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class OneWayDirents_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OneWayDirents_Impl(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep);
+ ~OneWayDirents_Impl() = default;
+ OneWayDirents_Impl(OneWayDirents_Impl&& other) = default;
+ OneWayDirents_Impl& operator=(OneWayDirents_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using CountNumDirectories = CountNumDirectories_Impl<CountNumDirectoriesResponse>;
+ using ReadDir = ReadDir_Impl<ReadDirResponse>;
+ using ConsumeDirectories = ConsumeDirectories_Impl<ConsumeDirectoriesResponse>;
+ using OneWayDirents = OneWayDirents_Impl;
+ };
+
+ // 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 CountNumDirectories_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ CountNumDirectories_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer);
+ ~CountNumDirectories_Impl() = default;
+ CountNumDirectories_Impl(CountNumDirectories_Impl&& other) = default;
+ CountNumDirectories_Impl& operator=(CountNumDirectories_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 ReadDir_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ReadDir_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~ReadDir_Impl() = default;
+ ReadDir_Impl(ReadDir_Impl&& other) = default;
+ ReadDir_Impl& operator=(ReadDir_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 ConsumeDirectories_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ ConsumeDirectories_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer);
+ ~ConsumeDirectories_Impl() = default;
+ ConsumeDirectories_Impl(ConsumeDirectories_Impl&& other) = default;
+ ConsumeDirectories_Impl& operator=(ConsumeDirectories_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ using Super::Unwrap;
+ using Super::value;
+ using Super::operator->;
+ using Super::operator*;
+ };
+ class OneWayDirents_Impl final : private ::fidl::internal::StatusAndError {
+ using Super = ::fidl::internal::StatusAndError;
+ public:
+ OneWayDirents_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep);
+ ~OneWayDirents_Impl() = default;
+ OneWayDirents_Impl(OneWayDirents_Impl&& other) = default;
+ OneWayDirents_Impl& operator=(OneWayDirents_Impl&& other) = default;
+ using Super::status;
+ using Super::error;
+ using Super::ok;
+ };
+
+ public:
+ using CountNumDirectories = CountNumDirectories_Impl<CountNumDirectoriesResponse>;
+ using ReadDir = ReadDir_Impl<ReadDirResponse>;
+ using ConsumeDirectories = ConsumeDirectories_Impl<ConsumeDirectoriesResponse>;
+ using OneWayDirents = OneWayDirents_Impl;
+ };
+
+ 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_; }
+
+ // Iterate over the dirents and return the number of directories within them.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ ResultOf::CountNumDirectories CountNumDirectories(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+
+ // Iterate over the dirents and return the number of directories within them.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::CountNumDirectories CountNumDirectories(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer);
+
+ // Return a vector of dirents. Empty request. Response may stack-allocate.
+ // Allocates 192 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ReadDir ReadDir();
+
+ // Return a vector of dirents. Empty request. Response may stack-allocate.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ReadDir ReadDir(::fidl::BytePart _response_buffer);
+
+ // Consume dirents. Empty response. Request may stack-allocate.
+ // Allocates 192 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::ConsumeDirectories ConsumeDirectories(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+
+ // Consume dirents. Empty response. Request may stack-allocate.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::ConsumeDirectories ConsumeDirectories(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer);
+
+ // Binding will not wait for response.
+ // But here we send an eventpair which the server will signal upon receipt of message.
+ // Request is heap-allocated.
+ ResultOf::OneWayDirents OneWayDirents(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep);
+
+ // Binding will not wait for response.
+ // But here we send an eventpair which the server will signal upon receipt of message.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::OneWayDirents OneWayDirents(::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ zx_status_t HandleEvents(EventHandlers handlers);
+ 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:
+
+ // Iterate over the dirents and return the number of directories within them.
+ // Allocates 24 bytes of response buffer on the stack. Request is heap-allocated.
+ static ResultOf::CountNumDirectories CountNumDirectories(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+
+ // Iterate over the dirents and return the number of directories within them.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::CountNumDirectories CountNumDirectories(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer);
+
+ // Return a vector of dirents. Empty request. Response may stack-allocate.
+ // Allocates 192 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ReadDir ReadDir(::zx::unowned_channel _client_end);
+
+ // Return a vector of dirents. Empty request. Response may stack-allocate.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ReadDir ReadDir(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+
+ // Consume dirents. Empty response. Request may stack-allocate.
+ // Allocates 192 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::ConsumeDirectories ConsumeDirectories(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+
+ // Consume dirents. Empty response. Request may stack-allocate.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::ConsumeDirectories ConsumeDirectories(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::fidl::BytePart _response_buffer);
+
+ // Binding will not wait for response.
+ // But here we send an eventpair which the server will signal upon receipt of message.
+ // Request is heap-allocated.
+ static ResultOf::OneWayDirents OneWayDirents(::zx::unowned_channel _client_end, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep);
+
+ // Binding will not wait for response.
+ // But here we send an eventpair which the server will signal upon receipt of message.
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::OneWayDirents OneWayDirents(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep);
+
+ // Handle all possible events defined in this protocol.
+ // Blocks to consume exactly one message from the channel, then call the corresponding handler
+ // defined in |EventHandlers|. The return status of the handler function is folded with any
+ // transport-level errors and returned.
+ static zx_status_t HandleEvents(::zx::unowned_channel client_end, EventHandlers handlers);
+ };
+
+ // 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:
+
+ // Iterate over the dirents and return the number of directories within them.
+ static ::fidl::DecodeResult<CountNumDirectoriesResponse> CountNumDirectories(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<CountNumDirectoriesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Return a vector of dirents. Empty request. Response may stack-allocate.
+ static ::fidl::DecodeResult<ReadDirResponse> ReadDir(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer);
+
+ // Consume dirents. Empty response. Request may stack-allocate.
+ static ::fidl::DecodeResult<ConsumeDirectoriesResponse> ConsumeDirectories(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<ConsumeDirectoriesRequest> params, ::fidl::BytePart response_buffer);
+
+ // Binding will not wait for response.
+ // But here we send an eventpair which the server will signal upon receipt of message.
+ static ::fidl::internal::StatusAndError OneWayDirents(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<OneWayDirentsRequest> params);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = DirEntTestInterface;
+ using _Base = ::fidl::CompleterBase;
+
+ class CountNumDirectoriesCompleterBase : public _Base {
+ public:
+ void Reply(int64_t num_dir);
+ void Reply(::fidl::BytePart _buffer, int64_t num_dir);
+ void Reply(::fidl::DecodedMessage<CountNumDirectoriesResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using CountNumDirectoriesCompleter = ::fidl::Completer<CountNumDirectoriesCompleterBase>;
+
+ virtual void CountNumDirectories(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, CountNumDirectoriesCompleter::Sync _completer) = 0;
+
+ class ReadDirCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+ void Reply(::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+ void Reply(::fidl::DecodedMessage<ReadDirResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ReadDirCompleter = ::fidl::Completer<ReadDirCompleterBase>;
+
+ virtual void ReadDir(ReadDirCompleter::Sync _completer) = 0;
+
+ class ConsumeDirectoriesCompleterBase : public _Base {
+ public:
+ void Reply();
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ConsumeDirectoriesCompleter = ::fidl::Completer<ConsumeDirectoriesCompleterBase>;
+
+ virtual void ConsumeDirectories(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ConsumeDirectoriesCompleter::Sync _completer) = 0;
+
+ using OneWayDirentsCompleter = ::fidl::Completer<>;
+
+ virtual void OneWayDirents(::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents, ::zx::eventpair ep, OneWayDirentsCompleter::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);
+ }
+
+ // Event
+ static zx_status_t SendOnDirentsEvent(::zx::unowned_channel _chan, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+
+ // Event
+ // Caller provides the backing storage for FIDL message via response buffers.
+ static zx_status_t SendOnDirentsEvent(::zx::unowned_channel _chan, ::fidl::BytePart _buffer, ::fidl::VectorView<::llcpp::fidl::test::llcpp::dirent::DirEnt> dirents);
+
+ // Event
+ // Messages are encoded in-place.
+ static zx_status_t SendOnDirentsEvent(::zx::unowned_channel _chan, ::fidl::DecodedMessage<OnDirentsResponse> params);
+
+
+ // Helper functions to fill in the transaction header in a |DecodedMessage<TransactionalMessage>|.
+ class SetTransactionHeaderFor final {
+ SetTransactionHeaderFor() = delete;
+ public:
+ static void CountNumDirectoriesRequest(const ::fidl::DecodedMessage<DirEntTestInterface::CountNumDirectoriesRequest>& _msg);
+ static void CountNumDirectoriesResponse(const ::fidl::DecodedMessage<DirEntTestInterface::CountNumDirectoriesResponse>& _msg);
+ static void ReadDirRequest(const ::fidl::DecodedMessage<DirEntTestInterface::ReadDirRequest>& _msg);
+ static void ReadDirResponse(const ::fidl::DecodedMessage<DirEntTestInterface::ReadDirResponse>& _msg);
+ static void ConsumeDirectoriesRequest(const ::fidl::DecodedMessage<DirEntTestInterface::ConsumeDirectoriesRequest>& _msg);
+ static void ConsumeDirectoriesResponse(const ::fidl::DecodedMessage<DirEntTestInterface::ConsumeDirectoriesResponse>& _msg);
+ static void OnDirentsResponse(const ::fidl::DecodedMessage<DirEntTestInterface::OnDirentsResponse>& _msg);
+ static void OneWayDirentsRequest(const ::fidl::DecodedMessage<DirEntTestInterface::OneWayDirentsRequest>& _msg);
+ };
+};
+
+} // namespace dirent
+} // namespace llcpp
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::dirent::DirEnt> : public std::true_type {};
+static_assert(std::is_standard_layout_v<::llcpp::fidl::test::llcpp::dirent::DirEnt>);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEnt, is_dir) == 0);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEnt, name) == 8);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEnt, some_flags) == 24);
+static_assert(sizeof(::llcpp::fidl::test::llcpp::dirent::DirEnt) == ::llcpp::fidl::test::llcpp::dirent::DirEnt::PrimarySize);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesRequest)
+ == ::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesRequest, dirents) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesResponse)
+ == ::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::CountNumDirectoriesResponse, num_dir) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ReadDirResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ReadDirResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ReadDirResponse)
+ == ::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ReadDirResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ReadDirResponse, dirents) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ConsumeDirectoriesRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ConsumeDirectoriesRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ConsumeDirectoriesRequest)
+ == ::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ConsumeDirectoriesRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::ConsumeDirectoriesRequest, dirents) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OnDirentsResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OnDirentsResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OnDirentsResponse)
+ == ::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OnDirentsResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OnDirentsResponse, dirents) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OneWayDirentsRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OneWayDirentsRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OneWayDirentsRequest)
+ == ::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OneWayDirentsRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OneWayDirentsRequest, dirents) == 16);
+static_assert(offsetof(::llcpp::fidl::test::llcpp::dirent::DirEntTestInterface::OneWayDirentsRequest, ep) == 32);
+
+} // namespace fidl
diff --git a/zircon/system/utest/fidl/BUILD.gn b/zircon/system/utest/fidl/BUILD.gn
index c687c26..b98e1ed 100644
--- a/zircon/system/utest/fidl/BUILD.gn
+++ b/zircon/system/utest/fidl/BUILD.gn
@@ -18,11 +18,16 @@
"llcpp_views_tests.cc",
"main.cc",
"on_error_handle_tests.cc",
+
+ # Generated coding table for generated/extra_messages.fidl Cannot yet use
+ # the FIDL_LIBS directive, since FIDL Tables are not supported in the C
+ # generator. See ./fidl/README.md for details.
+ "generated/extra_messages.c",
+ "generated/fidl_llcpp_llcpp.test.cc",
+ "generated/fidl_llcpp_tables_llcpp.test.c",
]
include_dirs = [ "generated" ]
public_deps = [
- ":example.c",
- ":fidl.test.coding.llcpp",
"$zx/system/ulib/fbl",
"$zx/system/ulib/fdio",
"$zx/system/ulib/fidl",
@@ -56,7 +61,6 @@
]
deps = [
":common",
- ":example.c",
":fidl-handle-policy-test-app",
]
@@ -74,8 +78,8 @@
"fidl_align_tests.cc",
"transformer_tests.c",
]
+ include_dirs = [ "generated" ]
deps = [
- ":example.c",
"$zx/system/ulib/fidl:fidl_base",
"$zx/system/ulib/unittest",
]
@@ -89,12 +93,3 @@
]
sources = [ "transformer.test.fidl" ]
}
-
-fidl_library("fidl.test.coding") {
- visibility = [ ":*" ]
- sources = [
- "extra_messages.test.fidl",
- "llcpp.test.fidl",
- "messages.test.fidl",
- ]
-}
diff --git a/zircon/system/utest/fidl/gen.sh b/zircon/system/utest/fidl/gen.sh
new file mode 100755
index 0000000..5748f0b
--- /dev/null
+++ b/zircon/system/utest/fidl/gen.sh
@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+
+set -eu
+set -o pipefail
+
+TEST_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+FUCHSIA_DIR="$( echo ${TEST_DIR} | sed -e 's,zircon/system/utest.*$,,' )"
+
+if [ -z ${FUCHSIA_BUILD_DIR+x} ] || [ -z ${ZIRCON_TOOLS_DIR+x} ]; then
+ echo "please use fx exec to run this script" 1>&2
+ exit 1
+fi
+
+FIDLC=${ZIRCON_TOOLS_DIR}/fidlc
+FIDLGEN=${FUCHSIA_BUILD_DIR}/host_x64/fidlgen_llcpp
+
+if [ ! -x "${FIDLC}" ]; then
+ echo "error: fidlc missing; did you fx clean-build?" 1>&2
+ exit 1
+fi
+
+if [ ! -x "${FIDLGEN}" ]; then
+ echo "error: fidlgen_llcpp missing; did you fx clean-build?" 1>&2
+ exit 1
+fi
+
+cd ${FUCHSIA_DIR}
+
+${FIDLC} \
+ --tables ${TEST_DIR}/generated/extra_messages.c \
+ --files ${TEST_DIR}/extra_messages.test.fidl
+
+${FIDLC} \
+ --tables ${TEST_DIR}/generated/transformer_tables.test.h \
+ --files ${TEST_DIR}/transformer.test.fidl
+
+for src_path in llcpp.test.fidl; do
+ src_name="$( basename "${src_path}" .fidl )"
+ json_name=${src_name}.json
+
+ # generate the json IR
+ cd ${TEST_DIR}
+ ${FIDLC} --json /tmp/${json_name} \
+ --tables generated/fidl_llcpp_tables_${src_name}.c \
+ --files ${src_path}
+
+ # generate llcpp bindings
+ ${FIDLGEN} -json /tmp/${json_name} \
+ -header fidl_llcpp_${src_name}.h \
+ -source fidl_llcpp_${src_name}.cc \
+ -include-base .
+
+ # generate tables in c
+ ${FIDLC} \
+ --tables ${TEST_DIR}/generated/extra_messages.c \
+ --files ${TEST_DIR}/extra_messages.test.fidl
+
+ mv fidl_llcpp_${src_name}.h generated/fidl_llcpp_${src_name}.h
+ mv fidl_llcpp_${src_name}.cc generated/fidl_llcpp_${src_name}.cc
+
+ # cleanup
+ rm /tmp/${json_name}
+done
diff --git a/zircon/system/utest/fidl/generated/extra_messages.c b/zircon/system/utest/fidl/generated/extra_messages.c
new file mode 100644
index 0000000..953cd91
--- /dev/null
+++ b/zircon/system/utest/fidl/generated/extra_messages.c
@@ -0,0 +1,526 @@
+// WARNING: This file is machine generated by fidlc.
+
+#include <lib/fidl/internal.h>
+
+// Forward declarations for old <-> V1 mappings
+
+static const fidl_type_t Vector2nonnullable23HandlehandlenonnullableTable;
+static const fidl_type_t Vector4294967295nonnullable6uint32Table;
+extern const fidl_type_t fidl_test_coding_LinearizerTestVectorOfUint32RequestTable;
+static const fidl_type_t Vector4294967295nonnullable27String4294967295nonnullableTable;
+extern const fidl_type_t fidl_test_coding_LinearizerTestVectorOfStringRequestTable;
+extern const fidl_type_t fidl_test_coding_Uint8EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Uint64EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Uint32EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Uint16EnumStructTable;
+extern const fidl_type_t fidl_test_coding_StructWithManyHandlesTable;
+extern const fidl_type_t fidl_test_coding_StructWithHandleTable;
+extern const fidl_type_t fidl_test_coding_SampleNullableXUnionStructTable;
+extern const fidl_type_t fidl_test_coding_IntStructTable;
+extern const fidl_type_t fidl_test_coding_SampleXUnionTable;
+extern const fidl_type_t fidl_test_coding_SampleXUnionNullableRefTable;
+extern const fidl_type_t fidl_test_coding_SampleXUnionStructTable;
+extern const fidl_type_t fidl_test_coding_SampleUnionTable;
+extern const fidl_type_t fidl_test_coding_SampleStrictXUnionTable;
+extern const fidl_type_t fidl_test_coding_SampleStrictXUnionNullableRefTable;
+extern const fidl_type_t fidl_test_coding_SampleStrictXUnionStructTable;
+extern const fidl_type_t fidl_test_coding_Int8EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Int64EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Int32EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Int32BitsStructTable;
+extern const fidl_type_t fidl_test_coding_Int16EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Int16BitsStructTable;
+static const fidl_type_t v1_Vector2nonnullable26v1_HandlehandlenonnullableTable;
+static const fidl_type_t v1_Vector4294967295nonnullable6uint32Table;
+extern const fidl_type_t v1_fidl_test_coding_LinearizerTestVectorOfUint32RequestTable;
+static const fidl_type_t v1_Vector4294967295nonnullable30v1_String4294967295nonnullableTable;
+extern const fidl_type_t v1_fidl_test_coding_LinearizerTestVectorOfStringRequestTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint8EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint64EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint32EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint16EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_StructWithManyHandlesTable;
+extern const fidl_type_t v1_fidl_test_coding_StructWithHandleTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleNullableXUnionStructTable;
+extern const fidl_type_t v1_fidl_test_coding_IntStructTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleXUnionTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleXUnionNullableRefTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleXUnionStructTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleUnionTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionNullableRefTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int8EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int64EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int32EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int32BitsStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int16EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int16BitsStructTable;
+
+// Coding tables for old wire format.
+
+extern const fidl_type_t fidl_test_coding_Uint8EnumTable;
+extern const fidl_type_t fidl_test_coding_Uint8EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Uint64EnumTable;
+extern const fidl_type_t fidl_test_coding_Uint64EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Uint32EnumTable;
+extern const fidl_type_t fidl_test_coding_Uint32EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Uint16EnumTable;
+extern const fidl_type_t fidl_test_coding_Uint16EnumStructTable;
+extern const fidl_type_t fidl_test_coding_StructWithManyHandlesTable;
+extern const fidl_type_t fidl_test_coding_SmallerTableOfStructWithHandleTable;
+extern const fidl_type_t fidl_test_coding_StructWithHandleTable;
+extern const fidl_type_t fidl_test_coding_TableOfStructWithHandleTable;
+extern const fidl_type_t fidl_test_coding_SampleNullableXUnionStructTable;
+extern const fidl_type_t fidl_test_coding_IntStructTable;
+extern const fidl_type_t fidl_test_coding_SimpleTableTable;
+extern const fidl_type_t fidl_test_coding_SampleXUnionTable;
+extern const fidl_type_t fidl_test_coding_SampleXUnionNullableRefTable;
+extern const fidl_type_t fidl_test_coding_SampleXUnionStructTable;
+extern const fidl_type_t fidl_test_coding_SampleUnionTable;
+extern const fidl_type_t fidl_test_coding_SampleStrictXUnionTable;
+extern const fidl_type_t fidl_test_coding_SampleStrictXUnionNullableRefTable;
+extern const fidl_type_t fidl_test_coding_SampleStrictXUnionStructTable;
+extern const fidl_type_t fidl_test_coding_OlderSimpleTableTable;
+extern const fidl_type_t fidl_test_coding_NewerSimpleTableTable;
+extern const fidl_type_t fidl_test_coding_Int8EnumTable;
+extern const fidl_type_t fidl_test_coding_Int8EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Int64EnumTable;
+extern const fidl_type_t fidl_test_coding_Int64EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Int32EnumTable;
+extern const fidl_type_t fidl_test_coding_Int32EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Int32BitsTable;
+extern const fidl_type_t fidl_test_coding_Int32BitsStructTable;
+extern const fidl_type_t fidl_test_coding_Int16EnumTable;
+extern const fidl_type_t fidl_test_coding_Int16EnumStructTable;
+extern const fidl_type_t fidl_test_coding_Int16BitsTable;
+extern const fidl_type_t fidl_test_coding_Int16BitsStructTable;
+
+
+static const fidl_type_t HandlehandlenonnullableTable = {.type_tag=kFidlTypeHandle, {.coded_handle={.handle_subtype=ZX_OBJ_TYPE_NONE, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t Vector2nonnullable23HandlehandlenonnullableTable = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&HandlehandlenonnullableTable, .max_count=2u, .element_size=4u, .nullable=kFidlNullability_Nonnullable, .alt_type=&v1_Vector2nonnullable26v1_HandlehandlenonnullableTable}}};
+
+static const fidl_type_t Vector4294967295nonnullable6uint32Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=NULL, .max_count=4294967295u, .element_size=4u, .nullable=kFidlNullability_Nonnullable, .alt_type=&v1_Vector4294967295nonnullable6uint32Table}}};
+
+extern const fidl_type_t fidl_test_coding_LinearizerTestVectorOfUint32RequestTable;
+static const struct FidlStructField Fields52fidl_test_coding_LinearizerTestVectorOfUint32Request[] = {
+ /*FidlStructField*/{.type=&Vector4294967295nonnullable6uint32Table, .offset=16u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_LinearizerTestVectorOfUint32RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields52fidl_test_coding_LinearizerTestVectorOfUint32Request, .field_count=1u, .size=32u, .max_out_of_line=4294967295u, .contains_union=false, .name="fidl.test.coding/LinearizerTestVectorOfUint32Request", .alt_type=&v1_fidl_test_coding_LinearizerTestVectorOfUint32RequestTable}}};
+
+static const fidl_type_t String4294967295nonnullableTable = {.type_tag=kFidlTypeString, {.coded_string={.max_size=4294967295u, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t Vector4294967295nonnullable27String4294967295nonnullableTable = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&String4294967295nonnullableTable, .max_count=4294967295u, .element_size=16u, .nullable=kFidlNullability_Nonnullable, .alt_type=&v1_Vector4294967295nonnullable30v1_String4294967295nonnullableTable}}};
+
+extern const fidl_type_t fidl_test_coding_LinearizerTestVectorOfStringRequestTable;
+static const struct FidlStructField Fields52fidl_test_coding_LinearizerTestVectorOfStringRequest[] = {
+ /*FidlStructField*/{.type=&Vector4294967295nonnullable27String4294967295nonnullableTable, .offset=16u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_LinearizerTestVectorOfStringRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields52fidl_test_coding_LinearizerTestVectorOfStringRequest, .field_count=1u, .size=32u, .max_out_of_line=4294967295u, .contains_union=false, .name="fidl.test.coding/LinearizerTestVectorOfStringRequest", .alt_type=&v1_fidl_test_coding_LinearizerTestVectorOfStringRequestTable}}};
+
+
+static bool EnumValidatorFor_fidl_test_coding_Uint8Enum(uint64_t v) { return (v == 0ul) || (v == 255ul) || (v == 42ul) || false; }
+const fidl_type_t fidl_test_coding_Uint8EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint8, .validate=&EnumValidatorFor_fidl_test_coding_Uint8Enum, .name="fidl.test.coding/Uint8Enum"}}};
+
+static const struct FidlStructField Fields32fidl_test_coding_Uint8EnumStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Uint8EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Uint8EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32fidl_test_coding_Uint8EnumStruct, .field_count=1u, .size=1u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Uint8EnumStruct", .alt_type=&v1_fidl_test_coding_Uint8EnumStructTable}}};
+
+static bool EnumValidatorFor_fidl_test_coding_Uint64Enum(uint64_t v) { return (v == 0ul) || (v == 18446744073709551615ul) || (v == 42ul) || false; }
+const fidl_type_t fidl_test_coding_Uint64EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint64, .validate=&EnumValidatorFor_fidl_test_coding_Uint64Enum, .name="fidl.test.coding/Uint64Enum"}}};
+
+static const struct FidlStructField Fields33fidl_test_coding_Uint64EnumStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Uint64EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Uint64EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields33fidl_test_coding_Uint64EnumStruct, .field_count=1u, .size=8u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Uint64EnumStruct", .alt_type=&v1_fidl_test_coding_Uint64EnumStructTable}}};
+
+static bool EnumValidatorFor_fidl_test_coding_Uint32Enum(uint64_t v) { return (v == 0ul) || (v == 4294967295ul) || (v == 42ul) || false; }
+const fidl_type_t fidl_test_coding_Uint32EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint32, .validate=&EnumValidatorFor_fidl_test_coding_Uint32Enum, .name="fidl.test.coding/Uint32Enum"}}};
+
+static const struct FidlStructField Fields33fidl_test_coding_Uint32EnumStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Uint32EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Uint32EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields33fidl_test_coding_Uint32EnumStruct, .field_count=1u, .size=4u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Uint32EnumStruct", .alt_type=&v1_fidl_test_coding_Uint32EnumStructTable}}};
+
+static bool EnumValidatorFor_fidl_test_coding_Uint16Enum(uint64_t v) { return (v == 0ul) || (v == 65535ul) || (v == 42ul) || false; }
+const fidl_type_t fidl_test_coding_Uint16EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint16, .validate=&EnumValidatorFor_fidl_test_coding_Uint16Enum, .name="fidl.test.coding/Uint16Enum"}}};
+
+static const struct FidlStructField Fields33fidl_test_coding_Uint16EnumStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Uint16EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Uint16EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields33fidl_test_coding_Uint16EnumStruct, .field_count=1u, .size=2u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Uint16EnumStruct", .alt_type=&v1_fidl_test_coding_Uint16EnumStructTable}}};
+
+static const struct FidlStructField Fields38fidl_test_coding_StructWithManyHandles[] = {
+ /*FidlStructField*/{.type=&HandlehandlenonnullableTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=&HandlehandlenonnullableTable, .offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=&Vector2nonnullable23HandlehandlenonnullableTable, .offset=8u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_StructWithManyHandlesTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields38fidl_test_coding_StructWithManyHandles, .field_count=3u, .size=24u, .max_out_of_line=8u, .contains_union=false, .name="fidl.test.coding/StructWithManyHandles", .alt_type=&v1_fidl_test_coding_StructWithManyHandlesTable}}};
+
+static const struct FidlTableField Fields47fidl_test_coding_SmallerTableOfStructWithHandle[] = {
+ /*FidlTableField*/{.type=&fidl_test_coding_StructWithManyHandlesTable, .ordinal=2u}
+};
+const fidl_type_t fidl_test_coding_SmallerTableOfStructWithHandleTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields47fidl_test_coding_SmallerTableOfStructWithHandle, .field_count=1u, .name="fidl.test.coding/SmallerTableOfStructWithHandle"}}};
+
+static const struct FidlStructField Fields33fidl_test_coding_StructWithHandle[] = {
+ /*FidlStructField*/{.type=&HandlehandlenonnullableTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=8u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_StructWithHandleTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields33fidl_test_coding_StructWithHandle, .field_count=2u, .size=8u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/StructWithHandle", .alt_type=&v1_fidl_test_coding_StructWithHandleTable}}};
+
+static const struct FidlTableField Fields40fidl_test_coding_TableOfStructWithHandle[] = {
+ /*FidlTableField*/{.type=&fidl_test_coding_StructWithHandleTable, .ordinal=1u},
+ /*FidlTableField*/{.type=&fidl_test_coding_StructWithManyHandlesTable, .ordinal=2u}
+};
+const fidl_type_t fidl_test_coding_TableOfStructWithHandleTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields40fidl_test_coding_TableOfStructWithHandle, .field_count=2u, .name="fidl.test.coding/TableOfStructWithHandle"}}};
+
+static const struct FidlStructField Fields43fidl_test_coding_SampleNullableXUnionStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_SampleXUnionNullableRefTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_SampleNullableXUnionStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields43fidl_test_coding_SampleNullableXUnionStruct, .field_count=1u, .size=24u, .max_out_of_line=64u, .contains_union=false, .name="fidl.test.coding/SampleNullableXUnionStruct", .alt_type=&v1_fidl_test_coding_SampleNullableXUnionStructTable}}};
+
+static const struct FidlStructField Fields26fidl_test_coding_IntStruct[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=8u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_IntStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields26fidl_test_coding_IntStruct, .field_count=1u, .size=8u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/IntStruct", .alt_type=&v1_fidl_test_coding_IntStructTable}}};
+
+static const struct FidlTableField Fields28fidl_test_coding_SimpleTable[] = {
+ /*FidlTableField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=1u},
+ /*FidlTableField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=5u}
+};
+const fidl_type_t fidl_test_coding_SimpleTableTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields28fidl_test_coding_SimpleTable, .field_count=2u, .name="fidl.test.coding/SimpleTable"}}};
+
+static const struct FidlXUnionField Fields29fidl_test_coding_SampleXUnion[] = {
+ /*FidlXUnionField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=376675050u, .hashed_ordinal=376675050u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_test_coding_SimpleTableTable, .ordinal=586453270u, .hashed_ordinal=586453270u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=319709411u, .hashed_ordinal=319709411u, .explicit_ordinal=3u}
+};
+const fidl_type_t fidl_test_coding_SampleXUnionTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields29fidl_test_coding_SampleXUnion, .nullable=kFidlNullability_Nonnullable, .name="fidl.test.coding/SampleXUnion", .strictness=kFidlStrictness_Flexible, .alt_type=&v1_fidl_test_coding_SampleXUnionTable}}};
+static const struct FidlXUnionField Fields40fidl_test_coding_SampleXUnionNullableRef[] = {
+ /*FidlXUnionField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=376675050u, .hashed_ordinal=376675050u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_test_coding_SimpleTableTable, .ordinal=586453270u, .hashed_ordinal=586453270u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=319709411u, .hashed_ordinal=319709411u, .explicit_ordinal=3u}
+};
+const fidl_type_t fidl_test_coding_SampleXUnionNullableRefTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields40fidl_test_coding_SampleXUnionNullableRef, .nullable=kFidlNullability_Nullable, .name="fidl.test.coding/SampleXUnion", .strictness=kFidlStrictness_Flexible, .alt_type=&v1_fidl_test_coding_SampleXUnionNullableRefTable}}};
+static const struct FidlStructField Fields35fidl_test_coding_SampleXUnionStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_SampleXUnionTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_SampleXUnionStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35fidl_test_coding_SampleXUnionStruct, .field_count=1u, .size=24u, .max_out_of_line=64u, .contains_union=false, .name="fidl.test.coding/SampleXUnionStruct", .alt_type=&v1_fidl_test_coding_SampleXUnionStructTable}}};
+
+static const struct FidlUnionField Fields28fidl_test_coding_SampleUnion[] = {
+ /*FidlUnionField*/{.type=&fidl_test_coding_IntStructTable, .padding=8u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=&fidl_test_coding_SimpleTableTable, .padding=0u, .xunion_ordinal=2u},
+ /*FidlUnionField*/{.type=NULL, .padding=12u, .xunion_ordinal=3u}
+};
+const fidl_type_t fidl_test_coding_SampleUnionTable = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields28fidl_test_coding_SampleUnion, .field_count=3u, .data_offset=8u, .size=24u, .name="fidl.test.coding/SampleUnion", .alt_type=&v1_fidl_test_coding_SampleUnionTable}}};
+
+static const struct FidlXUnionField Fields35fidl_test_coding_SampleStrictXUnion[] = {
+ /*FidlXUnionField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=1928460319u, .hashed_ordinal=1928460319u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_test_coding_SimpleTableTable, .ordinal=915108668u, .hashed_ordinal=915108668u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=419938224u, .hashed_ordinal=419938224u, .explicit_ordinal=3u}
+};
+const fidl_type_t fidl_test_coding_SampleStrictXUnionTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields35fidl_test_coding_SampleStrictXUnion, .nullable=kFidlNullability_Nonnullable, .name="fidl.test.coding/SampleStrictXUnion", .strictness=kFidlStrictness_Strict, .alt_type=&v1_fidl_test_coding_SampleStrictXUnionTable}}};
+static const struct FidlXUnionField Fields46fidl_test_coding_SampleStrictXUnionNullableRef[] = {
+ /*FidlXUnionField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=1928460319u, .hashed_ordinal=1928460319u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_test_coding_SimpleTableTable, .ordinal=915108668u, .hashed_ordinal=915108668u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=419938224u, .hashed_ordinal=419938224u, .explicit_ordinal=3u}
+};
+const fidl_type_t fidl_test_coding_SampleStrictXUnionNullableRefTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields46fidl_test_coding_SampleStrictXUnionNullableRef, .nullable=kFidlNullability_Nullable, .name="fidl.test.coding/SampleStrictXUnion", .strictness=kFidlStrictness_Strict, .alt_type=&v1_fidl_test_coding_SampleStrictXUnionNullableRefTable}}};
+static const struct FidlStructField Fields41fidl_test_coding_SampleStrictXUnionStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_SampleStrictXUnionTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_SampleStrictXUnionStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields41fidl_test_coding_SampleStrictXUnionStruct, .field_count=1u, .size=24u, .max_out_of_line=64u, .contains_union=false, .name="fidl.test.coding/SampleStrictXUnionStruct", .alt_type=&v1_fidl_test_coding_SampleStrictXUnionStructTable}}};
+
+static const struct FidlTableField Fields33fidl_test_coding_OlderSimpleTable[] = {
+ /*FidlTableField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=1u}
+};
+const fidl_type_t fidl_test_coding_OlderSimpleTableTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields33fidl_test_coding_OlderSimpleTable, .field_count=1u, .name="fidl.test.coding/OlderSimpleTable"}}};
+
+static const struct FidlTableField Fields33fidl_test_coding_NewerSimpleTable[] = {
+ /*FidlTableField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=1u},
+ /*FidlTableField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=5u},
+ /*FidlTableField*/{.type=&fidl_test_coding_IntStructTable, .ordinal=6u}
+};
+const fidl_type_t fidl_test_coding_NewerSimpleTableTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields33fidl_test_coding_NewerSimpleTable, .field_count=3u, .name="fidl.test.coding/NewerSimpleTable"}}};
+
+static bool EnumValidatorFor_fidl_test_coding_Int8Enum(uint64_t v) { return (v == 18446744073709551488ul) || (v == 127ul) || (v == 42ul) || false; }
+const fidl_type_t fidl_test_coding_Int8EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Int8, .validate=&EnumValidatorFor_fidl_test_coding_Int8Enum, .name="fidl.test.coding/Int8Enum"}}};
+
+static const struct FidlStructField Fields31fidl_test_coding_Int8EnumStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Int8EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Int8EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields31fidl_test_coding_Int8EnumStruct, .field_count=1u, .size=1u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int8EnumStruct", .alt_type=&v1_fidl_test_coding_Int8EnumStructTable}}};
+
+static bool EnumValidatorFor_fidl_test_coding_Int64Enum(uint64_t v) { return (v == 9223372036854775808ul) || (v == 9223372036854775807ul) || (v == 42ul) || false; }
+const fidl_type_t fidl_test_coding_Int64EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Int64, .validate=&EnumValidatorFor_fidl_test_coding_Int64Enum, .name="fidl.test.coding/Int64Enum"}}};
+
+static const struct FidlStructField Fields32fidl_test_coding_Int64EnumStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Int64EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Int64EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32fidl_test_coding_Int64EnumStruct, .field_count=1u, .size=8u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int64EnumStruct", .alt_type=&v1_fidl_test_coding_Int64EnumStructTable}}};
+
+static bool EnumValidatorFor_fidl_test_coding_Int32Enum(uint64_t v) { return (v == 18446744071562067968ul) || (v == 2147483647ul) || (v == 42ul) || false; }
+const fidl_type_t fidl_test_coding_Int32EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Int32, .validate=&EnumValidatorFor_fidl_test_coding_Int32Enum, .name="fidl.test.coding/Int32Enum"}}};
+
+static const struct FidlStructField Fields32fidl_test_coding_Int32EnumStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Int32EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Int32EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32fidl_test_coding_Int32EnumStruct, .field_count=1u, .size=4u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int32EnumStruct", .alt_type=&v1_fidl_test_coding_Int32EnumStructTable}}};
+
+const fidl_type_t fidl_test_coding_Int32BitsTable = {.type_tag=kFidlTypeBits, {.coded_bits={.underlying_type=kFidlCodedPrimitive_Uint32, .mask=67110976ul, .name="fidl.test.coding/Int32Bits"}}};
+
+static const struct FidlStructField Fields32fidl_test_coding_Int32BitsStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Int32BitsTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Int32BitsStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32fidl_test_coding_Int32BitsStruct, .field_count=1u, .size=4u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int32BitsStruct", .alt_type=&v1_fidl_test_coding_Int32BitsStructTable}}};
+
+static bool EnumValidatorFor_fidl_test_coding_Int16Enum(uint64_t v) { return (v == 18446744073709518848ul) || (v == 32767ul) || (v == 42ul) || false; }
+const fidl_type_t fidl_test_coding_Int16EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Int16, .validate=&EnumValidatorFor_fidl_test_coding_Int16Enum, .name="fidl.test.coding/Int16Enum"}}};
+
+static const struct FidlStructField Fields32fidl_test_coding_Int16EnumStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Int16EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Int16EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32fidl_test_coding_Int16EnumStruct, .field_count=1u, .size=2u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int16EnumStruct", .alt_type=&v1_fidl_test_coding_Int16EnumStructTable}}};
+
+const fidl_type_t fidl_test_coding_Int16BitsTable = {.type_tag=kFidlTypeBits, {.coded_bits={.underlying_type=kFidlCodedPrimitive_Uint16, .mask=21ul, .name="fidl.test.coding/Int16Bits"}}};
+
+static const struct FidlStructField Fields32fidl_test_coding_Int16BitsStruct[] = {
+ /*FidlStructField*/{.type=&fidl_test_coding_Int16BitsTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t fidl_test_coding_Int16BitsStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32fidl_test_coding_Int16BitsStruct, .field_count=1u, .size=2u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int16BitsStruct", .alt_type=&v1_fidl_test_coding_Int16BitsStructTable}}};
+
+// Coding tables for v1 wire format.
+
+extern const fidl_type_t v1_fidl_test_coding_Uint8EnumTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint8EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint64EnumTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint64EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint32EnumTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint32EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint16EnumTable;
+extern const fidl_type_t v1_fidl_test_coding_Uint16EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_StructWithManyHandlesTable;
+extern const fidl_type_t v1_fidl_test_coding_SmallerTableOfStructWithHandleTable;
+extern const fidl_type_t v1_fidl_test_coding_StructWithHandleTable;
+extern const fidl_type_t v1_fidl_test_coding_TableOfStructWithHandleTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleNullableXUnionStructTable;
+extern const fidl_type_t v1_fidl_test_coding_IntStructTable;
+extern const fidl_type_t v1_fidl_test_coding_SimpleTableTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleXUnionTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleXUnionNullableRefTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleXUnionStructTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleUnionTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionNullableRefTable;
+extern const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionStructTable;
+extern const fidl_type_t v1_fidl_test_coding_OlderSimpleTableTable;
+extern const fidl_type_t v1_fidl_test_coding_NewerSimpleTableTable;
+extern const fidl_type_t v1_fidl_test_coding_Int8EnumTable;
+extern const fidl_type_t v1_fidl_test_coding_Int8EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int64EnumTable;
+extern const fidl_type_t v1_fidl_test_coding_Int64EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int32EnumTable;
+extern const fidl_type_t v1_fidl_test_coding_Int32EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int32BitsTable;
+extern const fidl_type_t v1_fidl_test_coding_Int32BitsStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int16EnumTable;
+extern const fidl_type_t v1_fidl_test_coding_Int16EnumStructTable;
+extern const fidl_type_t v1_fidl_test_coding_Int16BitsTable;
+extern const fidl_type_t v1_fidl_test_coding_Int16BitsStructTable;
+
+
+static const fidl_type_t v1_HandlehandlenonnullableTable = {.type_tag=kFidlTypeHandle, {.coded_handle={.handle_subtype=ZX_OBJ_TYPE_NONE, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t v1_Vector2nonnullable26v1_HandlehandlenonnullableTable = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&v1_HandlehandlenonnullableTable, .max_count=2u, .element_size=4u, .nullable=kFidlNullability_Nonnullable, .alt_type=&Vector2nonnullable23HandlehandlenonnullableTable}}};
+
+static const fidl_type_t v1_Vector4294967295nonnullable6uint32Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=NULL, .max_count=4294967295u, .element_size=4u, .nullable=kFidlNullability_Nonnullable, .alt_type=&Vector4294967295nonnullable6uint32Table}}};
+
+extern const fidl_type_t v1_fidl_test_coding_LinearizerTestVectorOfUint32RequestTable;
+static const struct FidlStructField Fields55v1_fidl_test_coding_LinearizerTestVectorOfUint32Request[] = {
+ /*FidlStructField*/{.type=&v1_Vector4294967295nonnullable6uint32Table, .offset=16u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_LinearizerTestVectorOfUint32RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields55v1_fidl_test_coding_LinearizerTestVectorOfUint32Request, .field_count=1u, .size=32u, .max_out_of_line=4294967295u, .contains_union=false, .name="fidl.test.coding/LinearizerTestVectorOfUint32Request", .alt_type=&fidl_test_coding_LinearizerTestVectorOfUint32RequestTable}}};
+
+static const fidl_type_t v1_String4294967295nonnullableTable = {.type_tag=kFidlTypeString, {.coded_string={.max_size=4294967295u, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t v1_Vector4294967295nonnullable30v1_String4294967295nonnullableTable = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&v1_String4294967295nonnullableTable, .max_count=4294967295u, .element_size=16u, .nullable=kFidlNullability_Nonnullable, .alt_type=&Vector4294967295nonnullable27String4294967295nonnullableTable}}};
+
+extern const fidl_type_t v1_fidl_test_coding_LinearizerTestVectorOfStringRequestTable;
+static const struct FidlStructField Fields55v1_fidl_test_coding_LinearizerTestVectorOfStringRequest[] = {
+ /*FidlStructField*/{.type=&v1_Vector4294967295nonnullable30v1_String4294967295nonnullableTable, .offset=16u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_LinearizerTestVectorOfStringRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields55v1_fidl_test_coding_LinearizerTestVectorOfStringRequest, .field_count=1u, .size=32u, .max_out_of_line=4294967295u, .contains_union=false, .name="fidl.test.coding/LinearizerTestVectorOfStringRequest", .alt_type=&fidl_test_coding_LinearizerTestVectorOfStringRequestTable}}};
+
+
+static bool EnumValidatorFor_v1_fidl_test_coding_Uint8Enum(uint64_t v) { return (v == 0ul) || (v == 255ul) || (v == 42ul) || false; }
+const fidl_type_t v1_fidl_test_coding_Uint8EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint8, .validate=&EnumValidatorFor_v1_fidl_test_coding_Uint8Enum, .name="fidl.test.coding/Uint8Enum"}}};
+
+static const struct FidlStructField Fields35v1_fidl_test_coding_Uint8EnumStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Uint8EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Uint8EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35v1_fidl_test_coding_Uint8EnumStruct, .field_count=1u, .size=1u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Uint8EnumStruct", .alt_type=&fidl_test_coding_Uint8EnumStructTable}}};
+
+static bool EnumValidatorFor_v1_fidl_test_coding_Uint64Enum(uint64_t v) { return (v == 0ul) || (v == 18446744073709551615ul) || (v == 42ul) || false; }
+const fidl_type_t v1_fidl_test_coding_Uint64EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint64, .validate=&EnumValidatorFor_v1_fidl_test_coding_Uint64Enum, .name="fidl.test.coding/Uint64Enum"}}};
+
+static const struct FidlStructField Fields36v1_fidl_test_coding_Uint64EnumStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Uint64EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Uint64EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields36v1_fidl_test_coding_Uint64EnumStruct, .field_count=1u, .size=8u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Uint64EnumStruct", .alt_type=&fidl_test_coding_Uint64EnumStructTable}}};
+
+static bool EnumValidatorFor_v1_fidl_test_coding_Uint32Enum(uint64_t v) { return (v == 0ul) || (v == 4294967295ul) || (v == 42ul) || false; }
+const fidl_type_t v1_fidl_test_coding_Uint32EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint32, .validate=&EnumValidatorFor_v1_fidl_test_coding_Uint32Enum, .name="fidl.test.coding/Uint32Enum"}}};
+
+static const struct FidlStructField Fields36v1_fidl_test_coding_Uint32EnumStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Uint32EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Uint32EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields36v1_fidl_test_coding_Uint32EnumStruct, .field_count=1u, .size=4u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Uint32EnumStruct", .alt_type=&fidl_test_coding_Uint32EnumStructTable}}};
+
+static bool EnumValidatorFor_v1_fidl_test_coding_Uint16Enum(uint64_t v) { return (v == 0ul) || (v == 65535ul) || (v == 42ul) || false; }
+const fidl_type_t v1_fidl_test_coding_Uint16EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint16, .validate=&EnumValidatorFor_v1_fidl_test_coding_Uint16Enum, .name="fidl.test.coding/Uint16Enum"}}};
+
+static const struct FidlStructField Fields36v1_fidl_test_coding_Uint16EnumStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Uint16EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Uint16EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields36v1_fidl_test_coding_Uint16EnumStruct, .field_count=1u, .size=2u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Uint16EnumStruct", .alt_type=&fidl_test_coding_Uint16EnumStructTable}}};
+
+static const struct FidlStructField Fields41v1_fidl_test_coding_StructWithManyHandles[] = {
+ /*FidlStructField*/{.type=&v1_HandlehandlenonnullableTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_HandlehandlenonnullableTable, .offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_Vector2nonnullable26v1_HandlehandlenonnullableTable, .offset=8u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_StructWithManyHandlesTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields41v1_fidl_test_coding_StructWithManyHandles, .field_count=3u, .size=24u, .max_out_of_line=8u, .contains_union=false, .name="fidl.test.coding/StructWithManyHandles", .alt_type=&fidl_test_coding_StructWithManyHandlesTable}}};
+
+static const struct FidlTableField Fields50v1_fidl_test_coding_SmallerTableOfStructWithHandle[] = {
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_StructWithManyHandlesTable, .ordinal=2u}
+};
+const fidl_type_t v1_fidl_test_coding_SmallerTableOfStructWithHandleTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields50v1_fidl_test_coding_SmallerTableOfStructWithHandle, .field_count=1u, .name="fidl.test.coding/SmallerTableOfStructWithHandle"}}};
+
+static const struct FidlStructField Fields36v1_fidl_test_coding_StructWithHandle[] = {
+ /*FidlStructField*/{.type=&v1_HandlehandlenonnullableTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=8u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_StructWithHandleTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields36v1_fidl_test_coding_StructWithHandle, .field_count=2u, .size=8u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/StructWithHandle", .alt_type=&fidl_test_coding_StructWithHandleTable}}};
+
+static const struct FidlTableField Fields43v1_fidl_test_coding_TableOfStructWithHandle[] = {
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_StructWithHandleTable, .ordinal=1u},
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_StructWithManyHandlesTable, .ordinal=2u}
+};
+const fidl_type_t v1_fidl_test_coding_TableOfStructWithHandleTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields43v1_fidl_test_coding_TableOfStructWithHandle, .field_count=2u, .name="fidl.test.coding/TableOfStructWithHandle"}}};
+
+static const struct FidlStructField Fields46v1_fidl_test_coding_SampleNullableXUnionStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_SampleXUnionNullableRefTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_SampleNullableXUnionStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields46v1_fidl_test_coding_SampleNullableXUnionStruct, .field_count=1u, .size=24u, .max_out_of_line=64u, .contains_union=false, .name="fidl.test.coding/SampleNullableXUnionStruct", .alt_type=&fidl_test_coding_SampleNullableXUnionStructTable}}};
+
+static const struct FidlStructField Fields29v1_fidl_test_coding_IntStruct[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=8u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_IntStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields29v1_fidl_test_coding_IntStruct, .field_count=1u, .size=8u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/IntStruct", .alt_type=&fidl_test_coding_IntStructTable}}};
+
+static const struct FidlTableField Fields31v1_fidl_test_coding_SimpleTable[] = {
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=1u},
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=5u}
+};
+const fidl_type_t v1_fidl_test_coding_SimpleTableTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields31v1_fidl_test_coding_SimpleTable, .field_count=2u, .name="fidl.test.coding/SimpleTable"}}};
+
+static const struct FidlXUnionField Fields32v1_fidl_test_coding_SampleXUnion[] = {
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=376675050u, .hashed_ordinal=376675050u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_SimpleTableTable, .ordinal=586453270u, .hashed_ordinal=586453270u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=319709411u, .hashed_ordinal=319709411u, .explicit_ordinal=3u}
+};
+const fidl_type_t v1_fidl_test_coding_SampleXUnionTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields32v1_fidl_test_coding_SampleXUnion, .nullable=kFidlNullability_Nonnullable, .name="fidl.test.coding/SampleXUnion", .strictness=kFidlStrictness_Flexible, .alt_type=&fidl_test_coding_SampleXUnionTable}}};
+static const struct FidlXUnionField Fields43v1_fidl_test_coding_SampleXUnionNullableRef[] = {
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=376675050u, .hashed_ordinal=376675050u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_SimpleTableTable, .ordinal=586453270u, .hashed_ordinal=586453270u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=319709411u, .hashed_ordinal=319709411u, .explicit_ordinal=3u}
+};
+const fidl_type_t v1_fidl_test_coding_SampleXUnionNullableRefTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields43v1_fidl_test_coding_SampleXUnionNullableRef, .nullable=kFidlNullability_Nullable, .name="fidl.test.coding/SampleXUnion", .strictness=kFidlStrictness_Flexible, .alt_type=&fidl_test_coding_SampleXUnionNullableRefTable}}};
+static const struct FidlStructField Fields38v1_fidl_test_coding_SampleXUnionStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_SampleXUnionTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_SampleXUnionStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields38v1_fidl_test_coding_SampleXUnionStruct, .field_count=1u, .size=24u, .max_out_of_line=64u, .contains_union=false, .name="fidl.test.coding/SampleXUnionStruct", .alt_type=&fidl_test_coding_SampleXUnionStructTable}}};
+
+static const struct FidlXUnionField Fields31v1_fidl_test_coding_SampleUnion[] = {
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_SimpleTableTable, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=3u, .hashed_ordinal=3u, .explicit_ordinal=3u}
+};
+const fidl_type_t v1_fidl_test_coding_SampleUnionTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields31v1_fidl_test_coding_SampleUnion, .nullable=kFidlNullability_Nonnullable, .name="fidl.test.coding/SampleUnion", .strictness=kFidlStrictness_Strict, .alt_type=&fidl_test_coding_SampleUnionTable}}};
+static const struct FidlXUnionField Fields38v1_fidl_test_coding_SampleStrictXUnion[] = {
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=1928460319u, .hashed_ordinal=1928460319u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_SimpleTableTable, .ordinal=915108668u, .hashed_ordinal=915108668u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=419938224u, .hashed_ordinal=419938224u, .explicit_ordinal=3u}
+};
+const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields38v1_fidl_test_coding_SampleStrictXUnion, .nullable=kFidlNullability_Nonnullable, .name="fidl.test.coding/SampleStrictXUnion", .strictness=kFidlStrictness_Strict, .alt_type=&fidl_test_coding_SampleStrictXUnionTable}}};
+static const struct FidlXUnionField Fields49v1_fidl_test_coding_SampleStrictXUnionNullableRef[] = {
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=1928460319u, .hashed_ordinal=1928460319u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&v1_fidl_test_coding_SimpleTableTable, .ordinal=915108668u, .hashed_ordinal=915108668u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kInt32Table, .ordinal=419938224u, .hashed_ordinal=419938224u, .explicit_ordinal=3u}
+};
+const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionNullableRefTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields49v1_fidl_test_coding_SampleStrictXUnionNullableRef, .nullable=kFidlNullability_Nullable, .name="fidl.test.coding/SampleStrictXUnion", .strictness=kFidlStrictness_Strict, .alt_type=&fidl_test_coding_SampleStrictXUnionNullableRefTable}}};
+static const struct FidlStructField Fields44v1_fidl_test_coding_SampleStrictXUnionStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_SampleStrictXUnionTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_SampleStrictXUnionStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields44v1_fidl_test_coding_SampleStrictXUnionStruct, .field_count=1u, .size=24u, .max_out_of_line=64u, .contains_union=false, .name="fidl.test.coding/SampleStrictXUnionStruct", .alt_type=&fidl_test_coding_SampleStrictXUnionStructTable}}};
+
+static const struct FidlTableField Fields36v1_fidl_test_coding_OlderSimpleTable[] = {
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=1u}
+};
+const fidl_type_t v1_fidl_test_coding_OlderSimpleTableTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields36v1_fidl_test_coding_OlderSimpleTable, .field_count=1u, .name="fidl.test.coding/OlderSimpleTable"}}};
+
+static const struct FidlTableField Fields36v1_fidl_test_coding_NewerSimpleTable[] = {
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=1u},
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=5u},
+ /*FidlTableField*/{.type=&v1_fidl_test_coding_IntStructTable, .ordinal=6u}
+};
+const fidl_type_t v1_fidl_test_coding_NewerSimpleTableTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields36v1_fidl_test_coding_NewerSimpleTable, .field_count=3u, .name="fidl.test.coding/NewerSimpleTable"}}};
+
+static bool EnumValidatorFor_v1_fidl_test_coding_Int8Enum(uint64_t v) { return (v == 18446744073709551488ul) || (v == 127ul) || (v == 42ul) || false; }
+const fidl_type_t v1_fidl_test_coding_Int8EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Int8, .validate=&EnumValidatorFor_v1_fidl_test_coding_Int8Enum, .name="fidl.test.coding/Int8Enum"}}};
+
+static const struct FidlStructField Fields34v1_fidl_test_coding_Int8EnumStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Int8EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Int8EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields34v1_fidl_test_coding_Int8EnumStruct, .field_count=1u, .size=1u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int8EnumStruct", .alt_type=&fidl_test_coding_Int8EnumStructTable}}};
+
+static bool EnumValidatorFor_v1_fidl_test_coding_Int64Enum(uint64_t v) { return (v == 9223372036854775808ul) || (v == 9223372036854775807ul) || (v == 42ul) || false; }
+const fidl_type_t v1_fidl_test_coding_Int64EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Int64, .validate=&EnumValidatorFor_v1_fidl_test_coding_Int64Enum, .name="fidl.test.coding/Int64Enum"}}};
+
+static const struct FidlStructField Fields35v1_fidl_test_coding_Int64EnumStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Int64EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Int64EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35v1_fidl_test_coding_Int64EnumStruct, .field_count=1u, .size=8u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int64EnumStruct", .alt_type=&fidl_test_coding_Int64EnumStructTable}}};
+
+static bool EnumValidatorFor_v1_fidl_test_coding_Int32Enum(uint64_t v) { return (v == 18446744071562067968ul) || (v == 2147483647ul) || (v == 42ul) || false; }
+const fidl_type_t v1_fidl_test_coding_Int32EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Int32, .validate=&EnumValidatorFor_v1_fidl_test_coding_Int32Enum, .name="fidl.test.coding/Int32Enum"}}};
+
+static const struct FidlStructField Fields35v1_fidl_test_coding_Int32EnumStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Int32EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Int32EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35v1_fidl_test_coding_Int32EnumStruct, .field_count=1u, .size=4u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int32EnumStruct", .alt_type=&fidl_test_coding_Int32EnumStructTable}}};
+
+const fidl_type_t v1_fidl_test_coding_Int32BitsTable = {.type_tag=kFidlTypeBits, {.coded_bits={.underlying_type=kFidlCodedPrimitive_Uint32, .mask=67110976ul, .name="fidl.test.coding/Int32Bits"}}};
+
+static const struct FidlStructField Fields35v1_fidl_test_coding_Int32BitsStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Int32BitsTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Int32BitsStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35v1_fidl_test_coding_Int32BitsStruct, .field_count=1u, .size=4u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int32BitsStruct", .alt_type=&fidl_test_coding_Int32BitsStructTable}}};
+
+static bool EnumValidatorFor_v1_fidl_test_coding_Int16Enum(uint64_t v) { return (v == 18446744073709518848ul) || (v == 32767ul) || (v == 42ul) || false; }
+const fidl_type_t v1_fidl_test_coding_Int16EnumTable = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Int16, .validate=&EnumValidatorFor_v1_fidl_test_coding_Int16Enum, .name="fidl.test.coding/Int16Enum"}}};
+
+static const struct FidlStructField Fields35v1_fidl_test_coding_Int16EnumStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Int16EnumTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Int16EnumStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35v1_fidl_test_coding_Int16EnumStruct, .field_count=1u, .size=2u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int16EnumStruct", .alt_type=&fidl_test_coding_Int16EnumStructTable}}};
+
+const fidl_type_t v1_fidl_test_coding_Int16BitsTable = {.type_tag=kFidlTypeBits, {.coded_bits={.underlying_type=kFidlCodedPrimitive_Uint16, .mask=21ul, .name="fidl.test.coding/Int16Bits"}}};
+
+static const struct FidlStructField Fields35v1_fidl_test_coding_Int16BitsStruct[] = {
+ /*FidlStructField*/{.type=&v1_fidl_test_coding_Int16BitsTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_fidl_test_coding_Int16BitsStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35v1_fidl_test_coding_Int16BitsStruct, .field_count=1u, .size=2u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/Int16BitsStruct", .alt_type=&fidl_test_coding_Int16BitsStructTable}}};
+
diff --git a/zircon/system/utest/fidl/generated/fidl_llcpp_llcpp.test.cc b/zircon/system/utest/fidl/generated/fidl_llcpp_llcpp.test.cc
new file mode 100644
index 0000000..b837879
--- /dev/null
+++ b/zircon/system/utest/fidl/generated/fidl_llcpp_llcpp.test.cc
@@ -0,0 +1,175 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fidl_llcpp_llcpp.test.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace coding {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kLlcpp_Action_Ordinal = 0x46bfc70900000000lu;
+[[maybe_unused]]
+constexpr uint64_t kLlcpp_Action_GenOrdinal = 0x63f4dc1b85d88fc2lu;
+extern "C" const fidl_type_t fidl_test_coding_LlcppActionRequestTable;
+extern "C" const fidl_type_t fidl_test_coding_LlcppActionResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_coding_LlcppActionResponseTable;
+
+} // namespace
+template <>
+Llcpp::ResultOf::Action_Impl<Llcpp::ActionResponse>::Action_Impl(::zx::unowned_channel _client_end) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ActionRequest, ::fidl::MessageDirection::kSending>();
+ ::fidl::internal::AlignedBuffer<_kWriteAllocSize> _write_bytes_inlined;
+ auto& _write_bytes_array = _write_bytes_inlined;
+ uint8_t* _write_bytes = _write_bytes_array.view().data();
+ memset(_write_bytes, 0, ActionRequest::PrimarySize);
+ ::fidl::BytePart _request_bytes(_write_bytes, _kWriteAllocSize, sizeof(ActionRequest));
+ ::fidl::DecodedMessage<ActionRequest> _decoded_request(std::move(_request_bytes));
+ Super::SetResult(
+ Llcpp::InPlace::Action(std::move(_client_end), Super::response_buffer()));
+}
+
+Llcpp::ResultOf::Action Llcpp::SyncClient::Action() {
+ return ResultOf::Action(::zx::unowned_channel(this->channel_));
+}
+
+Llcpp::ResultOf::Action Llcpp::Call::Action(::zx::unowned_channel _client_end) {
+ return ResultOf::Action(std::move(_client_end));
+}
+
+template <>
+Llcpp::UnownedResultOf::Action_Impl<Llcpp::ActionResponse>::Action_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ FIDL_ALIGNDECL uint8_t _write_bytes[sizeof(ActionRequest)] = {};
+ ::fidl::BytePart _request_buffer(_write_bytes, sizeof(_write_bytes));
+ memset(_request_buffer.data(), 0, ActionRequest::PrimarySize);
+ _request_buffer.set_actual(sizeof(ActionRequest));
+ ::fidl::DecodedMessage<ActionRequest> _decoded_request(std::move(_request_buffer));
+ Super::SetResult(
+ Llcpp::InPlace::Action(std::move(_client_end), std::move(_response_buffer)));
+}
+
+Llcpp::UnownedResultOf::Action Llcpp::SyncClient::Action(::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Action(::zx::unowned_channel(this->channel_), std::move(_response_buffer));
+}
+
+Llcpp::UnownedResultOf::Action Llcpp::Call::Action(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::Action(std::move(_client_end), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Llcpp::ActionResponse> Llcpp::InPlace::Action(::zx::unowned_channel _client_end, ::fidl::BytePart response_buffer) {
+ constexpr uint32_t _write_num_bytes = sizeof(ActionRequest);
+ ::fidl::internal::AlignedBuffer<_write_num_bytes> _write_bytes;
+ ::fidl::BytePart _request_buffer = _write_bytes.view();
+ _request_buffer.set_actual(_write_num_bytes);
+ ::fidl::DecodedMessage<ActionRequest> params(std::move(_request_buffer));
+ Llcpp::SetTransactionHeaderFor::ActionRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Llcpp::ActionResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<ActionRequest, ActionResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Llcpp::ActionResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Llcpp::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kLlcpp_Action_Ordinal:
+ case kLlcpp_Action_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<ActionRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ impl->Action(
+ Interface::ActionCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Llcpp::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Llcpp::Interface::ActionCompleterBase::Reply(int32_t v) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<ActionResponse, ::fidl::MessageDirection::kSending>();
+ FIDL_ALIGNDECL uint8_t _write_bytes[_kWriteAllocSize] = {};
+ auto& _response = *reinterpret_cast<ActionResponse*>(_write_bytes);
+ Llcpp::SetTransactionHeaderFor::ActionResponse(
+ ::fidl::DecodedMessage<ActionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ActionResponse::PrimarySize,
+ ActionResponse::PrimarySize)));
+ _response.v = std::move(v);
+ ::fidl::BytePart _response_bytes(_write_bytes, _kWriteAllocSize, sizeof(ActionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ActionResponse>(std::move(_response_bytes)));
+}
+
+void Llcpp::Interface::ActionCompleterBase::Reply(::fidl::BytePart _buffer, int32_t v) {
+ if (_buffer.capacity() < ActionResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ auto& _response = *reinterpret_cast<ActionResponse*>(_buffer.data());
+ Llcpp::SetTransactionHeaderFor::ActionResponse(
+ ::fidl::DecodedMessage<ActionResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ ActionResponse::PrimarySize,
+ ActionResponse::PrimarySize)));
+ _response.v = std::move(v);
+ _buffer.set_actual(sizeof(ActionResponse));
+ CompleterBase::SendReply(::fidl::DecodedMessage<ActionResponse>(std::move(_buffer)));
+}
+
+void Llcpp::Interface::ActionCompleterBase::Reply(::fidl::DecodedMessage<ActionResponse> params) {
+ Llcpp::SetTransactionHeaderFor::ActionResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Llcpp::SetTransactionHeaderFor::ActionRequest(const ::fidl::DecodedMessage<Llcpp::ActionRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLlcpp_Action_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Llcpp::SetTransactionHeaderFor::ActionResponse(const ::fidl::DecodedMessage<Llcpp::ActionResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kLlcpp_Action_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace coding
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
diff --git a/zircon/system/utest/fidl/generated/fidl_llcpp_llcpp.test.h b/zircon/system/utest/fidl/generated/fidl_llcpp_llcpp.test.h
new file mode 100644
index 0000000..5495376
--- /dev/null
+++ b/zircon/system/utest/fidl/generated/fidl_llcpp_llcpp.test.h
@@ -0,0 +1,220 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fidl {
+namespace test {
+namespace coding {
+
+class Llcpp;
+
+extern "C" const fidl_type_t fidl_test_coding_LlcppActionRequestTable;
+extern "C" const fidl_type_t v1_fidl_test_coding_LlcppActionRequestTable;
+extern "C" const fidl_type_t fidl_test_coding_LlcppActionResponseTable;
+extern "C" const fidl_type_t v1_fidl_test_coding_LlcppActionResponseTable;
+
+class Llcpp final {
+ Llcpp() = delete;
+ public:
+
+ struct ActionResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ int32_t v;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_test_coding_LlcppActionResponseTable;
+ static constexpr const fidl_type_t* AltType = &fidl_test_coding_LlcppActionResponseTable;
+ 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::kResponse;
+ };
+ using ActionRequest = ::fidl::AnyZeroArgMessage;
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class Action_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ Action_Impl(::zx::unowned_channel _client_end);
+ ~Action_Impl() = default;
+ Action_Impl(Action_Impl&& other) = default;
+ Action_Impl& operator=(Action_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 Action = Action_Impl<ActionResponse>;
+ };
+
+ // 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 Action_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ Action_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _response_buffer);
+ ~Action_Impl() = default;
+ Action_Impl(Action_Impl&& other) = default;
+ Action_Impl& operator=(Action_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 Action = Action_Impl<ActionResponse>;
+ };
+
+ 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 40 bytes of message buffer on the stack. No heap allocation necessary.
+ ResultOf::Action Action();
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::Action Action(::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 40 bytes of message buffer on the stack. No heap allocation necessary.
+ static ResultOf::Action Action(::zx::unowned_channel _client_end);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::Action Action(::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<ActionResponse> Action(::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 = Llcpp;
+ using _Base = ::fidl::CompleterBase;
+
+ class ActionCompleterBase : public _Base {
+ public:
+ void Reply(int32_t v);
+ void Reply(::fidl::BytePart _buffer, int32_t v);
+ void Reply(::fidl::DecodedMessage<ActionResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using ActionCompleter = ::fidl::Completer<ActionCompleterBase>;
+
+ virtual void Action(ActionCompleter::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 ActionRequest(const ::fidl::DecodedMessage<Llcpp::ActionRequest>& _msg);
+ static void ActionResponse(const ::fidl::DecodedMessage<Llcpp::ActionResponse>& _msg);
+ };
+};
+
+} // namespace coding
+} // namespace test
+} // namespace fidl
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fidl::test::coding::Llcpp::ActionResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::test::coding::Llcpp::ActionResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::test::coding::Llcpp::ActionResponse)
+ == ::llcpp::fidl::test::coding::Llcpp::ActionResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::test::coding::Llcpp::ActionResponse, v) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/utest/fidl/generated/fidl_llcpp_tables_llcpp.test.c b/zircon/system/utest/fidl/generated/fidl_llcpp_tables_llcpp.test.c
new file mode 100644
index 0000000..6b77181
--- /dev/null
+++ b/zircon/system/utest/fidl/generated/fidl_llcpp_tables_llcpp.test.c
@@ -0,0 +1,41 @@
+// WARNING: This file is machine generated by fidlc.
+
+#include <lib/fidl/internal.h>
+
+// Forward declarations for old <-> V1 mappings
+
+extern const fidl_type_t fidl_test_coding_LlcppActionRequestTable;
+extern const fidl_type_t fidl_test_coding_LlcppActionResponseTable;
+extern const fidl_type_t v1_fidl_test_coding_LlcppActionRequestTable;
+extern const fidl_type_t v1_fidl_test_coding_LlcppActionResponseTable;
+
+// Coding tables for old wire format.
+
+
+
+extern const fidl_type_t fidl_test_coding_LlcppActionRequestTable;
+static const struct FidlStructField Fields35fidl_test_coding_LlcppActionRequest[] = {};
+const fidl_type_t fidl_test_coding_LlcppActionRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35fidl_test_coding_LlcppActionRequest, .field_count=0u, .size=16u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/LlcppActionRequest", .alt_type=&v1_fidl_test_coding_LlcppActionRequestTable}}};
+
+extern const fidl_type_t fidl_test_coding_LlcppActionResponseTable;
+static const struct FidlStructField Fields36fidl_test_coding_LlcppActionResponse[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u}
+};
+const fidl_type_t fidl_test_coding_LlcppActionResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields36fidl_test_coding_LlcppActionResponse, .field_count=1u, .size=24u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/LlcppActionResponse", .alt_type=&v1_fidl_test_coding_LlcppActionResponseTable}}};
+
+
+// Coding tables for v1 wire format.
+
+
+
+extern const fidl_type_t v1_fidl_test_coding_LlcppActionRequestTable;
+static const struct FidlStructField Fields38v1_fidl_test_coding_LlcppActionRequest[] = {};
+const fidl_type_t v1_fidl_test_coding_LlcppActionRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields38v1_fidl_test_coding_LlcppActionRequest, .field_count=0u, .size=16u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/LlcppActionRequest", .alt_type=&fidl_test_coding_LlcppActionRequestTable}}};
+
+extern const fidl_type_t v1_fidl_test_coding_LlcppActionResponseTable;
+static const struct FidlStructField Fields39v1_fidl_test_coding_LlcppActionResponse[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u}
+};
+const fidl_type_t v1_fidl_test_coding_LlcppActionResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields39v1_fidl_test_coding_LlcppActionResponse, .field_count=1u, .size=24u, .max_out_of_line=0u, .contains_union=false, .name="fidl.test.coding/LlcppActionResponse", .alt_type=&fidl_test_coding_LlcppActionResponseTable}}};
+
+
diff --git a/zircon/system/utest/fidl/generated/transformer_tables.test.h b/zircon/system/utest/fidl/generated/transformer_tables.test.h
new file mode 100644
index 0000000..f273016
--- /dev/null
+++ b/zircon/system/utest/fidl/generated/transformer_tables.test.h
@@ -0,0 +1,721 @@
+// WARNING: This file is machine generated by fidlc.
+
+#include <lib/fidl/internal.h>
+
+// Forward declarations for old <-> V1 mappings
+
+static const fidl_type_t Array32_5uint8Table;
+static const fidl_type_t Array6_5uint8Table;
+static const fidl_type_t Vector4294967295nonnullable5uint8Table;
+static const fidl_type_t Vector4294967295nonnullable29example_StructSize3Alignment1Table;
+static const fidl_type_t Vector4294967295nonnullable29example_StructSize3Alignment2Table;
+static const fidl_type_t Vector4294967295nonnullable23HandlehandlenonnullableTable;
+static const fidl_type_t Array6_29example_StructSize3Alignment1Table;
+static const fidl_type_t Array8_29example_StructSize3Alignment2Table;
+static const fidl_type_t Vector4294967295nonnullable26example_UnionSize8Aligned4Table;
+extern const fidl_type_t example_StringUnionStructWrapperProtocolTheMethodRequestTable;
+extern const fidl_type_t example_StringUnionStructWrapperProtocolTheMethodResponseTable;
+static const fidl_type_t Array32_19example_SimpleTableTable;
+static const fidl_type_t Vector4294967295nullable27String4294967295nonnullableTable;
+extern const fidl_type_t example_FakeProtocolWrapSandwich4RequestTable;
+extern const fidl_type_t example_FakeProtocolSendSandwich1RequestTable;
+extern const fidl_type_t example_FakeProtocolSendSandwich5RequestTable;
+extern const fidl_type_t example_FakeProtocolSendSandwich7RequestTable;
+extern const fidl_type_t example_FakeProtocolSendMixedFieldsRequestTable;
+extern const fidl_type_t example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable;
+extern const fidl_type_t example_FakeProtocolRegression9RequestTable;
+extern const fidl_type_t example_FakeProtocolRegression9ResponseTable;
+extern const fidl_type_t example_UnionSize8Aligned4Table;
+extern const fidl_type_t example_Sandwich1Table;
+extern const fidl_type_t example_UnionSize36Alignment4Table;
+extern const fidl_type_t example_Sandwich4Table;
+extern const fidl_type_t example_UnionSize12Aligned4Table;
+extern const fidl_type_t example_StructSize3Alignment2Table;
+extern const fidl_type_t example_StructSize3Alignment1Table;
+extern const fidl_type_t example_UnionWithVectorTable;
+extern const fidl_type_t example_Sandwich6Table;
+extern const fidl_type_t example_StructSize16Alignment8Table;
+extern const fidl_type_t example_UnionSize24Alignment8Table;
+extern const fidl_type_t example_UnionOfUnionTable;
+extern const fidl_type_t example_StringUnionTable;
+extern const fidl_type_t example_StringUnionStructTable;
+extern const fidl_type_t example_StringUnionStructWrapperTable;
+extern const fidl_type_t example_Regression9ValueTable;
+extern const fidl_type_t example_FakeProtocol_Regression9_ResponseTable;
+extern const fidl_type_t example_FakeProtocol_Regression9_ResultTable;
+extern const fidl_type_t example_SimpleTableArrayStructTable;
+extern const fidl_type_t example_LauncherInfoTable;
+extern const fidl_type_t example_Regression5Table;
+extern const fidl_type_t example_EmptyStructTable;
+extern const fidl_type_t example_Regression6Table;
+static const fidl_type_t v1_Array32_5uint8Table;
+static const fidl_type_t v1_Array6_5uint8Table;
+static const fidl_type_t v1_Vector4294967295nonnullable5uint8Table;
+static const fidl_type_t v1_Vector4294967295nonnullable32v1_example_StructSize3Alignment1Table;
+static const fidl_type_t v1_Vector4294967295nonnullable32v1_example_StructSize3Alignment2Table;
+static const fidl_type_t v1_Vector4294967295nonnullable26v1_HandlehandlenonnullableTable;
+static const fidl_type_t v1_Array6_32v1_example_StructSize3Alignment1Table;
+static const fidl_type_t v1_Array8_32v1_example_StructSize3Alignment2Table;
+static const fidl_type_t v1_Vector4294967295nonnullable29v1_example_UnionSize8Aligned4Table;
+extern const fidl_type_t v1_example_StringUnionStructWrapperProtocolTheMethodRequestTable;
+extern const fidl_type_t v1_example_StringUnionStructWrapperProtocolTheMethodResponseTable;
+static const fidl_type_t v1_Array32_22v1_example_SimpleTableTable;
+static const fidl_type_t v1_Vector4294967295nullable30v1_String4294967295nonnullableTable;
+extern const fidl_type_t v1_example_FakeProtocolWrapSandwich4RequestTable;
+extern const fidl_type_t v1_example_FakeProtocolSendSandwich1RequestTable;
+extern const fidl_type_t v1_example_FakeProtocolSendSandwich5RequestTable;
+extern const fidl_type_t v1_example_FakeProtocolSendSandwich7RequestTable;
+extern const fidl_type_t v1_example_FakeProtocolSendMixedFieldsRequestTable;
+extern const fidl_type_t v1_example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable;
+extern const fidl_type_t v1_example_FakeProtocolRegression9RequestTable;
+extern const fidl_type_t v1_example_FakeProtocolRegression9ResponseTable;
+extern const fidl_type_t v1_example_UnionSize8Aligned4Table;
+extern const fidl_type_t v1_example_Sandwich1Table;
+extern const fidl_type_t v1_example_UnionSize36Alignment4Table;
+extern const fidl_type_t v1_example_Sandwich4Table;
+extern const fidl_type_t v1_example_UnionSize12Aligned4Table;
+extern const fidl_type_t v1_example_StructSize3Alignment2Table;
+extern const fidl_type_t v1_example_StructSize3Alignment1Table;
+extern const fidl_type_t v1_example_UnionWithVectorTable;
+extern const fidl_type_t v1_example_Sandwich6Table;
+extern const fidl_type_t v1_example_StructSize16Alignment8Table;
+extern const fidl_type_t v1_example_UnionSize24Alignment8Table;
+extern const fidl_type_t v1_example_UnionOfUnionTable;
+extern const fidl_type_t v1_example_StringUnionTable;
+static const fidl_type_t v1_Pointer22v1_example_StringUnionTable;
+extern const fidl_type_t v1_example_StringUnionStructTable;
+extern const fidl_type_t v1_example_StringUnionStructWrapperTable;
+extern const fidl_type_t v1_example_Regression9ValueTable;
+extern const fidl_type_t v1_example_FakeProtocol_Regression9_ResponseTable;
+extern const fidl_type_t v1_example_FakeProtocol_Regression9_ResultTable;
+extern const fidl_type_t v1_example_SimpleTableArrayStructTable;
+extern const fidl_type_t v1_example_LauncherInfoTable;
+extern const fidl_type_t v1_example_Regression5Table;
+extern const fidl_type_t v1_example_EmptyStructTable;
+extern const fidl_type_t v1_example_Regression6Table;
+
+// Coding tables for old wire format.
+
+extern const fidl_type_t example_UnionSize8Aligned4Table;
+extern const fidl_type_t example_Sandwich1Table;
+extern const fidl_type_t example_UnionSize36Alignment4Table;
+extern const fidl_type_t example_Sandwich4Table;
+extern const fidl_type_t example_UnionSize12Aligned4Table;
+extern const fidl_type_t example_StructSize3Alignment2Table;
+extern const fidl_type_t example_StructSize3Alignment1Table;
+extern const fidl_type_t example_UnionWithVectorTable;
+extern const fidl_type_t example_Sandwich6Table;
+extern const fidl_type_t example_StructSize16Alignment8Table;
+extern const fidl_type_t example_UnionSize24Alignment8Table;
+extern const fidl_type_t example_UnionOfUnionTable;
+extern const fidl_type_t example_StringUnionTable;
+extern const fidl_type_t example_StringUnionStructTable;
+extern const fidl_type_t example_StringUnionStructWrapperTable;
+extern const fidl_type_t example_Regression9ValueTable;
+extern const fidl_type_t example_FakeProtocol_Regression9_ResponseTable;
+extern const fidl_type_t example_FakeProtocol_Regression9_ResultTable;
+extern const fidl_type_t example_SimpleTableTable;
+extern const fidl_type_t example_SimpleTableArrayStructTable;
+extern const fidl_type_t example_LauncherInfoTable;
+extern const fidl_type_t example_EnumUint8Table;
+extern const fidl_type_t example_EnumUint32Table;
+extern const fidl_type_t example_Regression5Table;
+extern const fidl_type_t example_EmptyStructTable;
+extern const fidl_type_t example_BitsUint8Table;
+extern const fidl_type_t example_BitsUint32Table;
+extern const fidl_type_t example_Regression6Table;
+
+static const fidl_type_t Pointer17example_Sandwich1Table = {.type_tag=kFidlTypeStructPointer, {.coded_struct_pointer={.struct_type=&example_Sandwich1Table.coded_struct}}};
+static const fidl_type_t Pointer19example_StringUnionTable = {.type_tag=kFidlTypeUnionPointer, {.coded_union_pointer={.union_type=&example_StringUnionTable.coded_union}}};
+static const fidl_type_t Pointer19example_EmptyStructTable = {.type_tag=kFidlTypeStructPointer, {.coded_struct_pointer={.struct_type=&example_EmptyStructTable.coded_struct}}};
+
+static const fidl_type_t Array32_5uint8Table = {.type_tag=kFidlTypeArray, {.coded_array={.element=NULL, .array_size=32u, .element_size=1u, .alt_type=&v1_Array32_5uint8Table}}};
+
+static const fidl_type_t Array6_5uint8Table = {.type_tag=kFidlTypeArray, {.coded_array={.element=NULL, .array_size=6u, .element_size=1u, .alt_type=&v1_Array6_5uint8Table}}};
+
+static const fidl_type_t Vector4294967295nonnullable5uint8Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=NULL, .max_count=4294967295u, .element_size=1u, .nullable=kFidlNullability_Nonnullable, .alt_type=&v1_Vector4294967295nonnullable5uint8Table}}};
+
+static const fidl_type_t String4294967295nonnullableTable = {.type_tag=kFidlTypeString, {.coded_string={.max_size=4294967295u, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t Vector4294967295nonnullable29example_StructSize3Alignment1Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&example_StructSize3Alignment1Table, .max_count=4294967295u, .element_size=3u, .nullable=kFidlNullability_Nonnullable, .alt_type=&v1_Vector4294967295nonnullable32v1_example_StructSize3Alignment1Table}}};
+
+static const fidl_type_t Vector4294967295nonnullable29example_StructSize3Alignment2Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&example_StructSize3Alignment2Table, .max_count=4294967295u, .element_size=4u, .nullable=kFidlNullability_Nonnullable, .alt_type=&v1_Vector4294967295nonnullable32v1_example_StructSize3Alignment2Table}}};
+
+static const fidl_type_t HandlehandlenonnullableTable = {.type_tag=kFidlTypeHandle, {.coded_handle={.handle_subtype=ZX_OBJ_TYPE_NONE, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t Vector4294967295nonnullable23HandlehandlenonnullableTable = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&HandlehandlenonnullableTable, .max_count=4294967295u, .element_size=4u, .nullable=kFidlNullability_Nonnullable, .alt_type=&v1_Vector4294967295nonnullable26v1_HandlehandlenonnullableTable}}};
+
+static const fidl_type_t Array6_29example_StructSize3Alignment1Table = {.type_tag=kFidlTypeArray, {.coded_array={.element=&example_StructSize3Alignment1Table, .array_size=6u, .element_size=3u, .alt_type=&v1_Array6_32v1_example_StructSize3Alignment1Table}}};
+
+static const fidl_type_t Array8_29example_StructSize3Alignment2Table = {.type_tag=kFidlTypeArray, {.coded_array={.element=&example_StructSize3Alignment2Table, .array_size=8u, .element_size=4u, .alt_type=&v1_Array8_32v1_example_StructSize3Alignment2Table}}};
+
+static const fidl_type_t Vector4294967295nonnullable26example_UnionSize8Aligned4Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&example_UnionSize8Aligned4Table, .max_count=4294967295u, .element_size=8u, .nullable=kFidlNullability_Nonnullable, .alt_type=&v1_Vector4294967295nonnullable29v1_example_UnionSize8Aligned4Table}}};
+
+extern const fidl_type_t example_StringUnionStructWrapperProtocolTheMethodRequestTable;
+static const struct FidlStructField Fields56example_StringUnionStructWrapperProtocolTheMethodRequest[] = {
+ /*FidlStructField*/{.type=&example_StringUnionStructWrapperTable, .offset=16u, .padding=0u}
+};
+const fidl_type_t example_StringUnionStructWrapperProtocolTheMethodRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields56example_StringUnionStructWrapperProtocolTheMethodRequest, .field_count=1u, .size=48u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/StringUnionStructWrapperProtocolTheMethodRequest", .alt_type=&v1_example_StringUnionStructWrapperProtocolTheMethodRequestTable}}};
+
+extern const fidl_type_t example_StringUnionStructWrapperProtocolTheMethodResponseTable;
+static const struct FidlStructField Fields57example_StringUnionStructWrapperProtocolTheMethodResponse[] = {
+ /*FidlStructField*/{.type=&example_StringUnionStructWrapperTable, .offset=16u, .padding=0u}
+};
+const fidl_type_t example_StringUnionStructWrapperProtocolTheMethodResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields57example_StringUnionStructWrapperProtocolTheMethodResponse, .field_count=1u, .size=48u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/StringUnionStructWrapperProtocolTheMethodResponse", .alt_type=&v1_example_StringUnionStructWrapperProtocolTheMethodResponseTable}}};
+
+static const fidl_type_t Array32_19example_SimpleTableTable = {.type_tag=kFidlTypeArray, {.coded_array={.element=&example_SimpleTableTable, .array_size=32u, .element_size=16u, .alt_type=&v1_Array32_22v1_example_SimpleTableTable}}};
+
+static const fidl_type_t String200nonnullableTable = {.type_tag=kFidlTypeString, {.coded_string={.max_size=200u, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t Vector4294967295nullable27String4294967295nonnullableTable = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&String4294967295nonnullableTable, .max_count=4294967295u, .element_size=16u, .nullable=kFidlNullability_Nullable, .alt_type=&v1_Vector4294967295nullable30v1_String4294967295nonnullableTable}}};
+
+static const fidl_type_t HandlechannelnullableTable = {.type_tag=kFidlTypeHandle, {.coded_handle={.handle_subtype=ZX_OBJ_TYPE_CHANNEL, .nullable=kFidlNullability_Nullable}}};
+
+extern const fidl_type_t example_FakeProtocolWrapSandwich4RequestTable;
+static const struct FidlStructField Fields40example_FakeProtocolWrapSandwich4Request[] = {
+ /*FidlStructField*/{.type=&example_Sandwich4Table, .offset=16u, .padding=4u}
+};
+const fidl_type_t example_FakeProtocolWrapSandwich4RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields40example_FakeProtocolWrapSandwich4Request, .field_count=1u, .size=64u, .max_out_of_line=0u, .contains_union=true, .name="example/FakeProtocolWrapSandwich4Request", .alt_type=&v1_example_FakeProtocolWrapSandwich4RequestTable}}};
+
+extern const fidl_type_t example_FakeProtocolSendSandwich1RequestTable;
+static const struct FidlStructField Fields40example_FakeProtocolSendSandwich1Request[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=0u},
+ /*FidlStructField*/{.type=&example_UnionSize8Aligned4Table, .offset=20u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=32u, .padding=0u}
+};
+const fidl_type_t example_FakeProtocolSendSandwich1RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields40example_FakeProtocolSendSandwich1Request, .field_count=3u, .size=32u, .max_out_of_line=0u, .contains_union=true, .name="example/FakeProtocolSendSandwich1Request", .alt_type=&v1_example_FakeProtocolSendSandwich1RequestTable}}};
+
+extern const fidl_type_t example_FakeProtocolSendSandwich5RequestTable;
+static const struct FidlStructField Fields40example_FakeProtocolSendSandwich5Request[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u},
+ /*FidlStructField*/{.type=&example_UnionOfUnionTable, .offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=60u, .padding=4u}
+};
+const fidl_type_t example_FakeProtocolSendSandwich5RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields40example_FakeProtocolSendSandwich5Request, .field_count=3u, .size=64u, .max_out_of_line=0u, .contains_union=true, .name="example/FakeProtocolSendSandwich5Request", .alt_type=&v1_example_FakeProtocolSendSandwich5RequestTable}}};
+
+extern const fidl_type_t example_FakeProtocolSendSandwich7RequestTable;
+static const struct FidlStructField Fields40example_FakeProtocolSendSandwich7Request[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u},
+ /*FidlStructField*/{.type=&Pointer17example_Sandwich1Table, .offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=36u, .padding=4u}
+};
+const fidl_type_t example_FakeProtocolSendSandwich7RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields40example_FakeProtocolSendSandwich7Request, .field_count=3u, .size=40u, .max_out_of_line=16u, .contains_union=true, .name="example/FakeProtocolSendSandwich7Request", .alt_type=&v1_example_FakeProtocolSendSandwich7RequestTable}}};
+
+extern const fidl_type_t example_FakeProtocolSendMixedFieldsRequestTable;
+static const struct FidlStructField Fields42example_FakeProtocolSendMixedFieldsRequest[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=0u},
+ /*FidlStructField*/{.type=&example_UnionSize8Aligned4Table, .offset=20u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=30u, .padding=2u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=40u, .padding=0u},
+ /*FidlStructField*/{.type=&example_UnionSize8Aligned4Table, .offset=40u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=52u, .padding=4u}
+};
+const fidl_type_t example_FakeProtocolSendMixedFieldsRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields42example_FakeProtocolSendMixedFieldsRequest, .field_count=6u, .size=56u, .max_out_of_line=0u, .contains_union=true, .name="example/FakeProtocolSendMixedFieldsRequest", .alt_type=&v1_example_FakeProtocolSendMixedFieldsRequestTable}}};
+
+extern const fidl_type_t example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable;
+static const struct FidlStructField Fields65example_FakeProtocolSendFakeLauncherCreateComponentRequestRequest[] = {
+ /*FidlStructField*/{.type=&example_LauncherInfoTable, .offset=16u, .padding=0u},
+ /*FidlStructField*/{.type=&HandlehandlenonnullableTable, .offset=88u, .padding=4u}
+};
+const fidl_type_t example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields65example_FakeProtocolSendFakeLauncherCreateComponentRequestRequest, .field_count=2u, .size=96u, .max_out_of_line=4294967295u, .contains_union=false, .name="example/FakeProtocolSendFakeLauncherCreateComponentRequestRequest", .alt_type=&v1_example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable}}};
+
+extern const fidl_type_t example_FakeProtocolRegression9RequestTable;
+static const struct FidlStructField Fields38example_FakeProtocolRegression9Request[] = {};
+const fidl_type_t example_FakeProtocolRegression9RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields38example_FakeProtocolRegression9Request, .field_count=0u, .size=16u, .max_out_of_line=0u, .contains_union=false, .name="example/FakeProtocolRegression9Request", .alt_type=&v1_example_FakeProtocolRegression9RequestTable}}};
+
+extern const fidl_type_t example_FakeProtocolRegression9ResponseTable;
+static const struct FidlStructField Fields39example_FakeProtocolRegression9Response[] = {
+ /*FidlStructField*/{.type=&example_FakeProtocol_Regression9_ResultTable, .offset=16u, .padding=0u}
+};
+const fidl_type_t example_FakeProtocolRegression9ResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields39example_FakeProtocolRegression9Response, .field_count=1u, .size=56u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/FakeProtocolRegression9Response", .alt_type=&v1_example_FakeProtocolRegression9ResponseTable}}};
+
+
+static const struct FidlUnionField Fields26example_UnionSize8Aligned4[] = {
+ /*FidlUnionField*/{.type=NULL, .padding=3u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=NULL, .padding=3u, .xunion_ordinal=2u},
+ /*FidlUnionField*/{.type=NULL, .padding=0u, .xunion_ordinal=3u}
+};
+const fidl_type_t example_UnionSize8Aligned4Table = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields26example_UnionSize8Aligned4, .field_count=3u, .data_offset=4u, .size=8u, .name="example/UnionSize8Aligned4", .alt_type=&v1_example_UnionSize8Aligned4Table}}};
+
+static const struct FidlStructField Fields17example_Sandwich1[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=&example_UnionSize8Aligned4Table, .offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=16u, .padding=0u}
+};
+const fidl_type_t example_Sandwich1Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields17example_Sandwich1, .field_count=3u, .size=16u, .max_out_of_line=0u, .contains_union=true, .name="example/Sandwich1", .alt_type=&v1_example_Sandwich1Table}}};
+
+static const struct FidlUnionField Fields29example_UnionSize36Alignment4[] = {
+ /*FidlUnionField*/{.type=NULL, .padding=31u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=NULL, .padding=31u, .xunion_ordinal=2u},
+ /*FidlUnionField*/{.type=NULL, .padding=31u, .xunion_ordinal=3u},
+ /*FidlUnionField*/{.type=&Array32_5uint8Table, .padding=0u, .xunion_ordinal=4u}
+};
+const fidl_type_t example_UnionSize36Alignment4Table = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields29example_UnionSize36Alignment4, .field_count=4u, .data_offset=4u, .size=36u, .name="example/UnionSize36Alignment4", .alt_type=&v1_example_UnionSize36Alignment4Table}}};
+
+static const struct FidlStructField Fields17example_Sandwich4[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=&example_UnionSize36Alignment4Table, .offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=44u, .padding=0u}
+};
+const fidl_type_t example_Sandwich4Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields17example_Sandwich4, .field_count=3u, .size=44u, .max_out_of_line=0u, .contains_union=true, .name="example/Sandwich4", .alt_type=&v1_example_Sandwich4Table}}};
+
+static const struct FidlUnionField Fields27example_UnionSize12Aligned4[] = {
+ /*FidlUnionField*/{.type=NULL, .padding=7u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=NULL, .padding=7u, .xunion_ordinal=2u},
+ /*FidlUnionField*/{.type=NULL, .padding=7u, .xunion_ordinal=3u},
+ /*FidlUnionField*/{.type=&Array6_5uint8Table, .padding=2u, .xunion_ordinal=4u}
+};
+const fidl_type_t example_UnionSize12Aligned4Table = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields27example_UnionSize12Aligned4, .field_count=4u, .data_offset=4u, .size=12u, .name="example/UnionSize12Aligned4", .alt_type=&v1_example_UnionSize12Aligned4Table}}};
+
+static const struct FidlStructField Fields29example_StructSize3Alignment2[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=2u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=3u, .padding=1u}
+};
+const fidl_type_t example_StructSize3Alignment2Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields29example_StructSize3Alignment2, .field_count=2u, .size=4u, .max_out_of_line=0u, .contains_union=false, .name="example/StructSize3Alignment2", .alt_type=&v1_example_StructSize3Alignment2Table}}};
+
+static const struct FidlStructField Fields29example_StructSize3Alignment1[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=3u, .padding=0u}
+};
+const fidl_type_t example_StructSize3Alignment1Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields29example_StructSize3Alignment1, .field_count=1u, .size=3u, .max_out_of_line=0u, .contains_union=false, .name="example/StructSize3Alignment1", .alt_type=&v1_example_StructSize3Alignment1Table}}};
+
+static const struct FidlUnionField Fields23example_UnionWithVector[] = {
+ /*FidlUnionField*/{.type=NULL, .padding=15u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=&Vector4294967295nonnullable5uint8Table, .padding=0u, .xunion_ordinal=2u},
+ /*FidlUnionField*/{.type=&String4294967295nonnullableTable, .padding=0u, .xunion_ordinal=3u},
+ /*FidlUnionField*/{.type=&Vector4294967295nonnullable29example_StructSize3Alignment1Table, .padding=0u, .xunion_ordinal=4u},
+ /*FidlUnionField*/{.type=&Vector4294967295nonnullable29example_StructSize3Alignment2Table, .padding=0u, .xunion_ordinal=5u},
+ /*FidlUnionField*/{.type=&Vector4294967295nonnullable23HandlehandlenonnullableTable, .padding=0u, .xunion_ordinal=6u},
+ /*FidlUnionField*/{.type=&Array6_29example_StructSize3Alignment1Table, .padding=10u, .xunion_ordinal=7u},
+ /*FidlUnionField*/{.type=&Array8_29example_StructSize3Alignment2Table, .padding=8u, .xunion_ordinal=8u},
+ /*FidlUnionField*/{.type=&Vector4294967295nonnullable26example_UnionSize8Aligned4Table, .padding=0u, .xunion_ordinal=9u}
+};
+const fidl_type_t example_UnionWithVectorTable = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields23example_UnionWithVector, .field_count=9u, .data_offset=8u, .size=24u, .name="example/UnionWithVector", .alt_type=&v1_example_UnionWithVectorTable}}};
+
+static const struct FidlStructField Fields17example_Sandwich6[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=4u, .padding=4u},
+ /*FidlStructField*/{.type=&example_UnionWithVectorTable, .offset=8u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=36u, .padding=4u}
+};
+const fidl_type_t example_Sandwich6Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields17example_Sandwich6, .field_count=3u, .size=40u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/Sandwich6", .alt_type=&v1_example_Sandwich6Table}}};
+
+static const struct FidlStructField Fields30example_StructSize16Alignment8[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=8u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=16u, .padding=0u}
+};
+const fidl_type_t example_StructSize16Alignment8Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields30example_StructSize16Alignment8, .field_count=2u, .size=16u, .max_out_of_line=0u, .contains_union=false, .name="example/StructSize16Alignment8", .alt_type=&v1_example_StructSize16Alignment8Table}}};
+
+static const struct FidlUnionField Fields29example_UnionSize24Alignment8[] = {
+ /*FidlUnionField*/{.type=NULL, .padding=15u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=NULL, .padding=15u, .xunion_ordinal=2u},
+ /*FidlUnionField*/{.type=NULL, .padding=15u, .xunion_ordinal=3u},
+ /*FidlUnionField*/{.type=&example_StructSize16Alignment8Table, .padding=0u, .xunion_ordinal=4u}
+};
+const fidl_type_t example_UnionSize24Alignment8Table = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields29example_UnionSize24Alignment8, .field_count=4u, .data_offset=8u, .size=24u, .name="example/UnionSize24Alignment8", .alt_type=&v1_example_UnionSize24Alignment8Table}}};
+
+static const struct FidlUnionField Fields20example_UnionOfUnion[] = {
+ /*FidlUnionField*/{.type=NULL, .padding=23u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=&example_UnionSize8Aligned4Table, .padding=16u, .xunion_ordinal=2u},
+ /*FidlUnionField*/{.type=&example_UnionSize12Aligned4Table, .padding=12u, .xunion_ordinal=3u},
+ /*FidlUnionField*/{.type=&example_UnionSize24Alignment8Table, .padding=0u, .xunion_ordinal=4u}
+};
+const fidl_type_t example_UnionOfUnionTable = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields20example_UnionOfUnion, .field_count=4u, .data_offset=8u, .size=32u, .name="example/UnionOfUnion", .alt_type=&v1_example_UnionOfUnionTable}}};
+
+static const struct FidlUnionField Fields19example_StringUnion[] = {
+ /*FidlUnionField*/{.type=&String4294967295nonnullableTable, .padding=0u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=NULL, .padding=15u, .xunion_ordinal=2u}
+};
+const fidl_type_t example_StringUnionTable = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields19example_StringUnion, .field_count=2u, .data_offset=8u, .size=24u, .name="example/StringUnion", .alt_type=&v1_example_StringUnionTable}}};
+
+static const struct FidlStructField Fields25example_StringUnionStruct[] = {
+ /*FidlStructField*/{.type=&example_StringUnionTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=&Pointer19example_StringUnionTable, .offset=24u, .padding=0u}
+};
+const fidl_type_t example_StringUnionStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields25example_StringUnionStruct, .field_count=2u, .size=32u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/StringUnionStruct", .alt_type=&v1_example_StringUnionStructTable}}};
+
+static const struct FidlStructField Fields32example_StringUnionStructWrapper[] = {
+ /*FidlStructField*/{.type=&example_StringUnionStructTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t example_StringUnionStructWrapperTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32example_StringUnionStructWrapper, .field_count=1u, .size=32u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/StringUnionStructWrapper", .alt_type=&v1_example_StringUnionStructWrapperTable}}};
+
+static const struct FidlStructField Fields24example_Regression9Value[] = {
+ /*FidlStructField*/{.type=&example_StringUnionTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=&Pointer19example_StringUnionTable, .offset=24u, .padding=0u}
+};
+const fidl_type_t example_Regression9ValueTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields24example_Regression9Value, .field_count=2u, .size=32u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/Regression9Value", .alt_type=&v1_example_Regression9ValueTable}}};
+
+static const struct FidlStructField Fields41example_FakeProtocol_Regression9_Response[] = {
+ /*FidlStructField*/{.type=&example_Regression9ValueTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t example_FakeProtocol_Regression9_ResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields41example_FakeProtocol_Regression9_Response, .field_count=1u, .size=32u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/FakeProtocol_Regression9_Response", .alt_type=&v1_example_FakeProtocol_Regression9_ResponseTable}}};
+
+static const struct FidlUnionField Fields39example_FakeProtocol_Regression9_Result[] = {
+ /*FidlUnionField*/{.type=&example_FakeProtocol_Regression9_ResponseTable, .padding=0u, .xunion_ordinal=1u},
+ /*FidlUnionField*/{.type=NULL, .padding=28u, .xunion_ordinal=2u}
+};
+const fidl_type_t example_FakeProtocol_Regression9_ResultTable = {.type_tag=kFidlTypeUnion, {.coded_union={.fields=Fields39example_FakeProtocol_Regression9_Result, .field_count=2u, .data_offset=8u, .size=40u, .name="example/FakeProtocol_Regression9_Result", .alt_type=&v1_example_FakeProtocol_Regression9_ResultTable}}};
+
+static const struct FidlTableField Fields19example_SimpleTable[] = {
+ /*FidlTableField*/{.type=&fidl_internal_kUint32Table, .ordinal=1u}
+};
+const fidl_type_t example_SimpleTableTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields19example_SimpleTable, .field_count=1u, .name="example/SimpleTable"}}};
+
+static const struct FidlStructField Fields30example_SimpleTableArrayStruct[] = {
+ /*FidlStructField*/{.type=&Array32_19example_SimpleTableTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t example_SimpleTableArrayStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields30example_SimpleTableArrayStruct, .field_count=1u, .size=32u, .max_out_of_line=48u, .contains_union=false, .name="example/SimpleTableArrayStruct", .alt_type=&v1_example_SimpleTableArrayStructTable}}};
+
+static const struct FidlStructField Fields20example_LauncherInfo[] = {
+ /*FidlStructField*/{.type=&String200nonnullableTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=&Vector4294967295nullable27String4294967295nonnullableTable, .offset=16u, .padding=0u},
+ /*FidlStructField*/{.type=&Pointer19example_EmptyStructTable, .offset=32u, .padding=0u},
+ /*FidlStructField*/{.type=&Pointer19example_EmptyStructTable, .offset=40u, .padding=0u},
+ /*FidlStructField*/{.type=&HandlechannelnullableTable, .offset=48u, .padding=4u},
+ /*FidlStructField*/{.type=&Pointer19example_EmptyStructTable, .offset=56u, .padding=0u},
+ /*FidlStructField*/{.type=&Pointer19example_EmptyStructTable, .offset=64u, .padding=0u}
+};
+const fidl_type_t example_LauncherInfoTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields20example_LauncherInfo, .field_count=7u, .size=72u, .max_out_of_line=4294967295u, .contains_union=false, .name="example/LauncherInfo", .alt_type=&v1_example_LauncherInfoTable}}};
+
+static bool EnumValidatorFor_example_EnumUint8(uint64_t v) { return (v == 8ul) || false; }
+const fidl_type_t example_EnumUint8Table = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint8, .validate=&EnumValidatorFor_example_EnumUint8, .name="example/EnumUint8"}}};
+
+static bool EnumValidatorFor_example_EnumUint32(uint64_t v) { return (v == 842084399ul) || false; }
+const fidl_type_t example_EnumUint32Table = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint32, .validate=&EnumValidatorFor_example_EnumUint32, .name="example/EnumUint32"}}};
+
+static const struct FidlStructField Fields19example_Regression5[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=1u, .padding=3u},
+ /*FidlStructField*/{.type=&example_EnumUint32Table, .offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=&example_EnumUint8Table, .offset=8u, .padding=1u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=12u, .padding=4u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=25u, .padding=7u}
+};
+const fidl_type_t example_Regression5Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields19example_Regression5, .field_count=6u, .size=32u, .max_out_of_line=0u, .contains_union=false, .name="example/Regression5", .alt_type=&v1_example_Regression5Table}}};
+
+static const struct FidlStructField Fields19example_EmptyStruct[] = {};
+const fidl_type_t example_EmptyStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields19example_EmptyStruct, .field_count=0u, .size=1u, .max_out_of_line=0u, .contains_union=false, .name="example/EmptyStruct", .alt_type=&v1_example_EmptyStructTable}}};
+
+const fidl_type_t example_BitsUint8Table = {.type_tag=kFidlTypeBits, {.coded_bits={.underlying_type=kFidlCodedPrimitive_Uint8, .mask=8ul, .name="example/BitsUint8"}}};
+
+const fidl_type_t example_BitsUint32Table = {.type_tag=kFidlTypeBits, {.coded_bits={.underlying_type=kFidlCodedPrimitive_Uint32, .mask=805306371ul, .name="example/BitsUint32"}}};
+
+static const struct FidlStructField Fields19example_Regression6[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=1u, .padding=3u},
+ /*FidlStructField*/{.type=&example_BitsUint32Table, .offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=&example_BitsUint8Table, .offset=8u, .padding=1u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=12u, .padding=4u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=25u, .padding=7u}
+};
+const fidl_type_t example_Regression6Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields19example_Regression6, .field_count=6u, .size=32u, .max_out_of_line=0u, .contains_union=false, .name="example/Regression6", .alt_type=&v1_example_Regression6Table}}};
+
+// Coding tables for v1 wire format.
+
+extern const fidl_type_t v1_example_UnionSize8Aligned4Table;
+extern const fidl_type_t v1_example_Sandwich1Table;
+extern const fidl_type_t v1_example_UnionSize36Alignment4Table;
+extern const fidl_type_t v1_example_Sandwich4Table;
+extern const fidl_type_t v1_example_UnionSize12Aligned4Table;
+extern const fidl_type_t v1_example_StructSize3Alignment2Table;
+extern const fidl_type_t v1_example_StructSize3Alignment1Table;
+extern const fidl_type_t v1_example_UnionWithVectorTable;
+extern const fidl_type_t v1_example_Sandwich6Table;
+extern const fidl_type_t v1_example_StructSize16Alignment8Table;
+extern const fidl_type_t v1_example_UnionSize24Alignment8Table;
+extern const fidl_type_t v1_example_UnionOfUnionTable;
+extern const fidl_type_t v1_example_StringUnionTable;
+static const fidl_type_t v1_Pointer22v1_example_StringUnionTable;
+extern const fidl_type_t v1_example_StringUnionStructTable;
+extern const fidl_type_t v1_example_StringUnionStructWrapperTable;
+extern const fidl_type_t v1_example_Regression9ValueTable;
+extern const fidl_type_t v1_example_FakeProtocol_Regression9_ResponseTable;
+extern const fidl_type_t v1_example_FakeProtocol_Regression9_ResultTable;
+extern const fidl_type_t v1_example_SimpleTableTable;
+extern const fidl_type_t v1_example_SimpleTableArrayStructTable;
+extern const fidl_type_t v1_example_LauncherInfoTable;
+extern const fidl_type_t v1_example_EnumUint8Table;
+extern const fidl_type_t v1_example_EnumUint32Table;
+extern const fidl_type_t v1_example_Regression5Table;
+extern const fidl_type_t v1_example_EmptyStructTable;
+extern const fidl_type_t v1_example_BitsUint8Table;
+extern const fidl_type_t v1_example_BitsUint32Table;
+extern const fidl_type_t v1_example_Regression6Table;
+
+static const fidl_type_t v1_Pointer20v1_example_Sandwich1Table = {.type_tag=kFidlTypeStructPointer, {.coded_struct_pointer={.struct_type=&v1_example_Sandwich1Table.coded_struct}}};
+static const fidl_type_t v1_Pointer22v1_example_EmptyStructTable = {.type_tag=kFidlTypeStructPointer, {.coded_struct_pointer={.struct_type=&v1_example_EmptyStructTable.coded_struct}}};
+
+static const fidl_type_t v1_Array32_5uint8Table = {.type_tag=kFidlTypeArray, {.coded_array={.element=NULL, .array_size=32u, .element_size=1u, .alt_type=&Array32_5uint8Table}}};
+
+static const fidl_type_t v1_Array6_5uint8Table = {.type_tag=kFidlTypeArray, {.coded_array={.element=NULL, .array_size=6u, .element_size=1u, .alt_type=&Array6_5uint8Table}}};
+
+static const fidl_type_t v1_Vector4294967295nonnullable5uint8Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=NULL, .max_count=4294967295u, .element_size=1u, .nullable=kFidlNullability_Nonnullable, .alt_type=&Vector4294967295nonnullable5uint8Table}}};
+
+static const fidl_type_t v1_String4294967295nonnullableTable = {.type_tag=kFidlTypeString, {.coded_string={.max_size=4294967295u, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t v1_Vector4294967295nonnullable32v1_example_StructSize3Alignment1Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&v1_example_StructSize3Alignment1Table, .max_count=4294967295u, .element_size=3u, .nullable=kFidlNullability_Nonnullable, .alt_type=&Vector4294967295nonnullable29example_StructSize3Alignment1Table}}};
+
+static const fidl_type_t v1_Vector4294967295nonnullable32v1_example_StructSize3Alignment2Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&v1_example_StructSize3Alignment2Table, .max_count=4294967295u, .element_size=4u, .nullable=kFidlNullability_Nonnullable, .alt_type=&Vector4294967295nonnullable29example_StructSize3Alignment2Table}}};
+
+static const fidl_type_t v1_HandlehandlenonnullableTable = {.type_tag=kFidlTypeHandle, {.coded_handle={.handle_subtype=ZX_OBJ_TYPE_NONE, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t v1_Vector4294967295nonnullable26v1_HandlehandlenonnullableTable = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&v1_HandlehandlenonnullableTable, .max_count=4294967295u, .element_size=4u, .nullable=kFidlNullability_Nonnullable, .alt_type=&Vector4294967295nonnullable23HandlehandlenonnullableTable}}};
+
+static const fidl_type_t v1_Array6_32v1_example_StructSize3Alignment1Table = {.type_tag=kFidlTypeArray, {.coded_array={.element=&v1_example_StructSize3Alignment1Table, .array_size=6u, .element_size=3u, .alt_type=&Array6_29example_StructSize3Alignment1Table}}};
+
+static const fidl_type_t v1_Array8_32v1_example_StructSize3Alignment2Table = {.type_tag=kFidlTypeArray, {.coded_array={.element=&v1_example_StructSize3Alignment2Table, .array_size=8u, .element_size=4u, .alt_type=&Array8_29example_StructSize3Alignment2Table}}};
+
+static const fidl_type_t v1_Vector4294967295nonnullable29v1_example_UnionSize8Aligned4Table = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&v1_example_UnionSize8Aligned4Table, .max_count=4294967295u, .element_size=24u, .nullable=kFidlNullability_Nonnullable, .alt_type=&Vector4294967295nonnullable26example_UnionSize8Aligned4Table}}};
+
+extern const fidl_type_t v1_example_StringUnionStructWrapperProtocolTheMethodRequestTable;
+static const struct FidlStructField Fields59v1_example_StringUnionStructWrapperProtocolTheMethodRequest[] = {
+ /*FidlStructField*/{.type=&v1_example_StringUnionStructWrapperTable, .offset=16u, .padding=0u}
+};
+const fidl_type_t v1_example_StringUnionStructWrapperProtocolTheMethodRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields59v1_example_StringUnionStructWrapperProtocolTheMethodRequest, .field_count=1u, .size=64u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/StringUnionStructWrapperProtocolTheMethodRequest", .alt_type=&example_StringUnionStructWrapperProtocolTheMethodRequestTable}}};
+
+extern const fidl_type_t v1_example_StringUnionStructWrapperProtocolTheMethodResponseTable;
+static const struct FidlStructField Fields60v1_example_StringUnionStructWrapperProtocolTheMethodResponse[] = {
+ /*FidlStructField*/{.type=&v1_example_StringUnionStructWrapperTable, .offset=16u, .padding=0u}
+};
+const fidl_type_t v1_example_StringUnionStructWrapperProtocolTheMethodResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields60v1_example_StringUnionStructWrapperProtocolTheMethodResponse, .field_count=1u, .size=64u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/StringUnionStructWrapperProtocolTheMethodResponse", .alt_type=&example_StringUnionStructWrapperProtocolTheMethodResponseTable}}};
+
+static const fidl_type_t v1_Array32_22v1_example_SimpleTableTable = {.type_tag=kFidlTypeArray, {.coded_array={.element=&v1_example_SimpleTableTable, .array_size=32u, .element_size=16u, .alt_type=&Array32_19example_SimpleTableTable}}};
+
+static const fidl_type_t v1_String200nonnullableTable = {.type_tag=kFidlTypeString, {.coded_string={.max_size=200u, .nullable=kFidlNullability_Nonnullable}}};
+
+static const fidl_type_t v1_Vector4294967295nullable30v1_String4294967295nonnullableTable = {.type_tag=kFidlTypeVector, {.coded_vector={.element=&v1_String4294967295nonnullableTable, .max_count=4294967295u, .element_size=16u, .nullable=kFidlNullability_Nullable, .alt_type=&Vector4294967295nullable27String4294967295nonnullableTable}}};
+
+static const fidl_type_t v1_HandlechannelnullableTable = {.type_tag=kFidlTypeHandle, {.coded_handle={.handle_subtype=ZX_OBJ_TYPE_CHANNEL, .nullable=kFidlNullability_Nullable}}};
+
+extern const fidl_type_t v1_example_FakeProtocolWrapSandwich4RequestTable;
+static const struct FidlStructField Fields43v1_example_FakeProtocolWrapSandwich4Request[] = {
+ /*FidlStructField*/{.type=&v1_example_Sandwich4Table, .offset=16u, .padding=0u}
+};
+const fidl_type_t v1_example_FakeProtocolWrapSandwich4RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields43v1_example_FakeProtocolWrapSandwich4Request, .field_count=1u, .size=56u, .max_out_of_line=32u, .contains_union=true, .name="example/FakeProtocolWrapSandwich4Request", .alt_type=&example_FakeProtocolWrapSandwich4RequestTable}}};
+
+extern const fidl_type_t v1_example_FakeProtocolSendSandwich1RequestTable;
+static const struct FidlStructField Fields43v1_example_FakeProtocolSendSandwich1Request[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u},
+ /*FidlStructField*/{.type=&v1_example_UnionSize8Aligned4Table, .offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=52u, .padding=4u}
+};
+const fidl_type_t v1_example_FakeProtocolSendSandwich1RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields43v1_example_FakeProtocolSendSandwich1Request, .field_count=3u, .size=56u, .max_out_of_line=8u, .contains_union=true, .name="example/FakeProtocolSendSandwich1Request", .alt_type=&example_FakeProtocolSendSandwich1RequestTable}}};
+
+extern const fidl_type_t v1_example_FakeProtocolSendSandwich5RequestTable;
+static const struct FidlStructField Fields43v1_example_FakeProtocolSendSandwich5Request[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u},
+ /*FidlStructField*/{.type=&v1_example_UnionOfUnionTable, .offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=52u, .padding=4u}
+};
+const fidl_type_t v1_example_FakeProtocolSendSandwich5RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields43v1_example_FakeProtocolSendSandwich5Request, .field_count=3u, .size=56u, .max_out_of_line=40u, .contains_union=true, .name="example/FakeProtocolSendSandwich5Request", .alt_type=&example_FakeProtocolSendSandwich5RequestTable}}};
+
+extern const fidl_type_t v1_example_FakeProtocolSendSandwich7RequestTable;
+static const struct FidlStructField Fields43v1_example_FakeProtocolSendSandwich7Request[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u},
+ /*FidlStructField*/{.type=&v1_Pointer20v1_example_Sandwich1Table, .offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=36u, .padding=4u}
+};
+const fidl_type_t v1_example_FakeProtocolSendSandwich7RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields43v1_example_FakeProtocolSendSandwich7Request, .field_count=3u, .size=40u, .max_out_of_line=48u, .contains_union=true, .name="example/FakeProtocolSendSandwich7Request", .alt_type=&example_FakeProtocolSendSandwich7RequestTable}}};
+
+extern const fidl_type_t v1_example_FakeProtocolSendMixedFieldsRequestTable;
+static const struct FidlStructField Fields45v1_example_FakeProtocolSendMixedFieldsRequest[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=20u, .padding=4u},
+ /*FidlStructField*/{.type=&v1_example_UnionSize8Aligned4Table, .offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=50u, .padding=6u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=64u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_example_UnionSize8Aligned4Table, .offset=64u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=92u, .padding=4u}
+};
+const fidl_type_t v1_example_FakeProtocolSendMixedFieldsRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields45v1_example_FakeProtocolSendMixedFieldsRequest, .field_count=6u, .size=96u, .max_out_of_line=16u, .contains_union=true, .name="example/FakeProtocolSendMixedFieldsRequest", .alt_type=&example_FakeProtocolSendMixedFieldsRequestTable}}};
+
+extern const fidl_type_t v1_example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable;
+static const struct FidlStructField Fields68v1_example_FakeProtocolSendFakeLauncherCreateComponentRequestRequest[] = {
+ /*FidlStructField*/{.type=&v1_example_LauncherInfoTable, .offset=16u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_HandlehandlenonnullableTable, .offset=88u, .padding=4u}
+};
+const fidl_type_t v1_example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields68v1_example_FakeProtocolSendFakeLauncherCreateComponentRequestRequest, .field_count=2u, .size=96u, .max_out_of_line=4294967295u, .contains_union=false, .name="example/FakeProtocolSendFakeLauncherCreateComponentRequestRequest", .alt_type=&example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable}}};
+
+extern const fidl_type_t v1_example_FakeProtocolRegression9RequestTable;
+static const struct FidlStructField Fields41v1_example_FakeProtocolRegression9Request[] = {};
+const fidl_type_t v1_example_FakeProtocolRegression9RequestTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields41v1_example_FakeProtocolRegression9Request, .field_count=0u, .size=16u, .max_out_of_line=0u, .contains_union=false, .name="example/FakeProtocolRegression9Request", .alt_type=&example_FakeProtocolRegression9RequestTable}}};
+
+extern const fidl_type_t v1_example_FakeProtocolRegression9ResponseTable;
+static const struct FidlStructField Fields42v1_example_FakeProtocolRegression9Response[] = {
+ /*FidlStructField*/{.type=&v1_example_FakeProtocol_Regression9_ResultTable, .offset=16u, .padding=0u}
+};
+const fidl_type_t v1_example_FakeProtocolRegression9ResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields42v1_example_FakeProtocolRegression9Response, .field_count=1u, .size=40u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/FakeProtocolRegression9Response", .alt_type=&example_FakeProtocolRegression9ResponseTable}}};
+
+
+static const struct FidlXUnionField Fields29v1_example_UnionSize8Aligned4[] = {
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint32Table, .ordinal=3u, .hashed_ordinal=3u, .explicit_ordinal=3u}
+};
+const fidl_type_t v1_example_UnionSize8Aligned4Table = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=3u, .fields=Fields29v1_example_UnionSize8Aligned4, .nullable=kFidlNullability_Nonnullable, .name="example/UnionSize8Aligned4", .strictness=kFidlStrictness_Strict, .alt_type=&example_UnionSize8Aligned4Table}}};
+static const struct FidlStructField Fields20v1_example_Sandwich1[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=4u, .padding=4u},
+ /*FidlStructField*/{.type=&v1_example_UnionSize8Aligned4Table, .offset=8u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=36u, .padding=4u}
+};
+const fidl_type_t v1_example_Sandwich1Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields20v1_example_Sandwich1, .field_count=3u, .size=40u, .max_out_of_line=8u, .contains_union=true, .name="example/Sandwich1", .alt_type=&example_Sandwich1Table}}};
+
+static const struct FidlXUnionField Fields32v1_example_UnionSize36Alignment4[] = {
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=3u, .hashed_ordinal=3u, .explicit_ordinal=3u},
+ /*FidlXUnionField*/{.type=&v1_Array32_5uint8Table, .ordinal=4u, .hashed_ordinal=4u, .explicit_ordinal=4u}
+};
+const fidl_type_t v1_example_UnionSize36Alignment4Table = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=4u, .fields=Fields32v1_example_UnionSize36Alignment4, .nullable=kFidlNullability_Nonnullable, .name="example/UnionSize36Alignment4", .strictness=kFidlStrictness_Strict, .alt_type=&example_UnionSize36Alignment4Table}}};
+static const struct FidlStructField Fields20v1_example_Sandwich4[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=4u, .padding=4u},
+ /*FidlStructField*/{.type=&v1_example_UnionSize36Alignment4Table, .offset=8u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=36u, .padding=4u}
+};
+const fidl_type_t v1_example_Sandwich4Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields20v1_example_Sandwich4, .field_count=3u, .size=40u, .max_out_of_line=32u, .contains_union=true, .name="example/Sandwich4", .alt_type=&example_Sandwich4Table}}};
+
+static const struct FidlXUnionField Fields30v1_example_UnionSize12Aligned4[] = {
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=3u, .hashed_ordinal=3u, .explicit_ordinal=3u},
+ /*FidlXUnionField*/{.type=&v1_Array6_5uint8Table, .ordinal=4u, .hashed_ordinal=4u, .explicit_ordinal=4u}
+};
+const fidl_type_t v1_example_UnionSize12Aligned4Table = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=4u, .fields=Fields30v1_example_UnionSize12Aligned4, .nullable=kFidlNullability_Nonnullable, .name="example/UnionSize12Aligned4", .strictness=kFidlStrictness_Strict, .alt_type=&example_UnionSize12Aligned4Table}}};
+static const struct FidlStructField Fields32v1_example_StructSize3Alignment2[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=2u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=3u, .padding=1u}
+};
+const fidl_type_t v1_example_StructSize3Alignment2Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32v1_example_StructSize3Alignment2, .field_count=2u, .size=4u, .max_out_of_line=0u, .contains_union=false, .name="example/StructSize3Alignment2", .alt_type=&example_StructSize3Alignment2Table}}};
+
+static const struct FidlStructField Fields32v1_example_StructSize3Alignment1[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=3u, .padding=0u}
+};
+const fidl_type_t v1_example_StructSize3Alignment1Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields32v1_example_StructSize3Alignment1, .field_count=1u, .size=3u, .max_out_of_line=0u, .contains_union=false, .name="example/StructSize3Alignment1", .alt_type=&example_StructSize3Alignment1Table}}};
+
+static const struct FidlXUnionField Fields26v1_example_UnionWithVector[] = {
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&v1_Vector4294967295nonnullable5uint8Table, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&v1_String4294967295nonnullableTable, .ordinal=3u, .hashed_ordinal=3u, .explicit_ordinal=3u},
+ /*FidlXUnionField*/{.type=&v1_Vector4294967295nonnullable32v1_example_StructSize3Alignment1Table, .ordinal=4u, .hashed_ordinal=4u, .explicit_ordinal=4u},
+ /*FidlXUnionField*/{.type=&v1_Vector4294967295nonnullable32v1_example_StructSize3Alignment2Table, .ordinal=5u, .hashed_ordinal=5u, .explicit_ordinal=5u},
+ /*FidlXUnionField*/{.type=&v1_Vector4294967295nonnullable26v1_HandlehandlenonnullableTable, .ordinal=6u, .hashed_ordinal=6u, .explicit_ordinal=6u},
+ /*FidlXUnionField*/{.type=&v1_Array6_32v1_example_StructSize3Alignment1Table, .ordinal=7u, .hashed_ordinal=7u, .explicit_ordinal=7u},
+ /*FidlXUnionField*/{.type=&v1_Array8_32v1_example_StructSize3Alignment2Table, .ordinal=8u, .hashed_ordinal=8u, .explicit_ordinal=8u},
+ /*FidlXUnionField*/{.type=&v1_Vector4294967295nonnullable29v1_example_UnionSize8Aligned4Table, .ordinal=9u, .hashed_ordinal=9u, .explicit_ordinal=9u}
+};
+const fidl_type_t v1_example_UnionWithVectorTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=9u, .fields=Fields26v1_example_UnionWithVector, .nullable=kFidlNullability_Nonnullable, .name="example/UnionWithVector", .strictness=kFidlStrictness_Strict, .alt_type=&example_UnionWithVectorTable}}};
+static const struct FidlStructField Fields20v1_example_Sandwich6[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=4u, .padding=4u},
+ /*FidlStructField*/{.type=&v1_example_UnionWithVectorTable, .offset=8u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=36u, .padding=4u}
+};
+const fidl_type_t v1_example_Sandwich6Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields20v1_example_Sandwich6, .field_count=3u, .size=40u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/Sandwich6", .alt_type=&example_Sandwich6Table}}};
+
+static const struct FidlStructField Fields33v1_example_StructSize16Alignment8[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=8u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=16u, .padding=0u}
+};
+const fidl_type_t v1_example_StructSize16Alignment8Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields33v1_example_StructSize16Alignment8, .field_count=2u, .size=16u, .max_out_of_line=0u, .contains_union=false, .name="example/StructSize16Alignment8", .alt_type=&example_StructSize16Alignment8Table}}};
+
+static const struct FidlXUnionField Fields32v1_example_UnionSize24Alignment8[] = {
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=3u, .hashed_ordinal=3u, .explicit_ordinal=3u},
+ /*FidlXUnionField*/{.type=&v1_example_StructSize16Alignment8Table, .ordinal=4u, .hashed_ordinal=4u, .explicit_ordinal=4u}
+};
+const fidl_type_t v1_example_UnionSize24Alignment8Table = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=4u, .fields=Fields32v1_example_UnionSize24Alignment8, .nullable=kFidlNullability_Nonnullable, .name="example/UnionSize24Alignment8", .strictness=kFidlStrictness_Strict, .alt_type=&example_UnionSize24Alignment8Table}}};
+static const struct FidlXUnionField Fields23v1_example_UnionOfUnion[] = {
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint8Table, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&v1_example_UnionSize8Aligned4Table, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u},
+ /*FidlXUnionField*/{.type=&v1_example_UnionSize12Aligned4Table, .ordinal=3u, .hashed_ordinal=3u, .explicit_ordinal=3u},
+ /*FidlXUnionField*/{.type=&v1_example_UnionSize24Alignment8Table, .ordinal=4u, .hashed_ordinal=4u, .explicit_ordinal=4u}
+};
+const fidl_type_t v1_example_UnionOfUnionTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=4u, .fields=Fields23v1_example_UnionOfUnion, .nullable=kFidlNullability_Nonnullable, .name="example/UnionOfUnion", .strictness=kFidlStrictness_Strict, .alt_type=&example_UnionOfUnionTable}}};
+static const struct FidlXUnionField Fields22v1_example_StringUnion[] = {
+ /*FidlXUnionField*/{.type=&v1_String4294967295nonnullableTable, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kBoolTable, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u}
+};
+const fidl_type_t v1_example_StringUnionTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=2u, .fields=Fields22v1_example_StringUnion, .nullable=kFidlNullability_Nonnullable, .name="example/StringUnion", .strictness=kFidlStrictness_Strict, .alt_type=&example_StringUnionTable}}};
+static const struct FidlXUnionField Fields34v1_Pointer22v1_example_StringUnion[] = {
+ /*FidlXUnionField*/{.type=&v1_String4294967295nonnullableTable, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kBoolTable, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u}
+};
+static const fidl_type_t v1_Pointer22v1_example_StringUnionTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=2u, .fields=Fields34v1_Pointer22v1_example_StringUnion, .nullable=kFidlNullability_Nullable, .name="example/StringUnion", .strictness=kFidlStrictness_Strict, .alt_type=&Pointer19example_StringUnionTable}}};
+static const struct FidlStructField Fields28v1_example_StringUnionStruct[] = {
+ /*FidlStructField*/{.type=&v1_example_StringUnionTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_Pointer22v1_example_StringUnionTable, .offset=24u, .padding=0u}
+};
+const fidl_type_t v1_example_StringUnionStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields28v1_example_StringUnionStruct, .field_count=2u, .size=48u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/StringUnionStruct", .alt_type=&example_StringUnionStructTable}}};
+
+static const struct FidlStructField Fields35v1_example_StringUnionStructWrapper[] = {
+ /*FidlStructField*/{.type=&v1_example_StringUnionStructTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_example_StringUnionStructWrapperTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields35v1_example_StringUnionStructWrapper, .field_count=1u, .size=48u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/StringUnionStructWrapper", .alt_type=&example_StringUnionStructWrapperTable}}};
+
+static const struct FidlStructField Fields27v1_example_Regression9Value[] = {
+ /*FidlStructField*/{.type=&v1_example_StringUnionTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_Pointer22v1_example_StringUnionTable, .offset=24u, .padding=0u}
+};
+const fidl_type_t v1_example_Regression9ValueTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields27v1_example_Regression9Value, .field_count=2u, .size=48u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/Regression9Value", .alt_type=&example_Regression9ValueTable}}};
+
+static const struct FidlStructField Fields44v1_example_FakeProtocol_Regression9_Response[] = {
+ /*FidlStructField*/{.type=&v1_example_Regression9ValueTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_example_FakeProtocol_Regression9_ResponseTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields44v1_example_FakeProtocol_Regression9_Response, .field_count=1u, .size=48u, .max_out_of_line=4294967295u, .contains_union=true, .name="example/FakeProtocol_Regression9_Response", .alt_type=&example_FakeProtocol_Regression9_ResponseTable}}};
+
+static const struct FidlXUnionField Fields42v1_example_FakeProtocol_Regression9_Result[] = {
+ /*FidlXUnionField*/{.type=&v1_example_FakeProtocol_Regression9_ResponseTable, .ordinal=1u, .hashed_ordinal=1u, .explicit_ordinal=1u},
+ /*FidlXUnionField*/{.type=&fidl_internal_kUint32Table, .ordinal=2u, .hashed_ordinal=2u, .explicit_ordinal=2u}
+};
+const fidl_type_t v1_example_FakeProtocol_Regression9_ResultTable = {.type_tag=kFidlTypeXUnion, {.coded_xunion={.field_count=2u, .fields=Fields42v1_example_FakeProtocol_Regression9_Result, .nullable=kFidlNullability_Nonnullable, .name="example/FakeProtocol_Regression9_Result", .strictness=kFidlStrictness_Strict, .alt_type=&example_FakeProtocol_Regression9_ResultTable}}};
+static const struct FidlTableField Fields22v1_example_SimpleTable[] = {
+ /*FidlTableField*/{.type=&fidl_internal_kUint32Table, .ordinal=1u}
+};
+const fidl_type_t v1_example_SimpleTableTable = {.type_tag=kFidlTypeTable, {.coded_table={.fields=Fields22v1_example_SimpleTable, .field_count=1u, .name="example/SimpleTable"}}};
+
+static const struct FidlStructField Fields33v1_example_SimpleTableArrayStruct[] = {
+ /*FidlStructField*/{.type=&v1_Array32_22v1_example_SimpleTableTable, .offset=0u, .padding=0u}
+};
+const fidl_type_t v1_example_SimpleTableArrayStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields33v1_example_SimpleTableArrayStruct, .field_count=1u, .size=32u, .max_out_of_line=48u, .contains_union=false, .name="example/SimpleTableArrayStruct", .alt_type=&example_SimpleTableArrayStructTable}}};
+
+static const struct FidlStructField Fields23v1_example_LauncherInfo[] = {
+ /*FidlStructField*/{.type=&v1_String200nonnullableTable, .offset=0u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_Vector4294967295nullable30v1_String4294967295nonnullableTable, .offset=16u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_Pointer22v1_example_EmptyStructTable, .offset=32u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_Pointer22v1_example_EmptyStructTable, .offset=40u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_HandlechannelnullableTable, .offset=48u, .padding=4u},
+ /*FidlStructField*/{.type=&v1_Pointer22v1_example_EmptyStructTable, .offset=56u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_Pointer22v1_example_EmptyStructTable, .offset=64u, .padding=0u}
+};
+const fidl_type_t v1_example_LauncherInfoTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields23v1_example_LauncherInfo, .field_count=7u, .size=72u, .max_out_of_line=4294967295u, .contains_union=false, .name="example/LauncherInfo", .alt_type=&example_LauncherInfoTable}}};
+
+static bool EnumValidatorFor_v1_example_EnumUint8(uint64_t v) { return (v == 8ul) || false; }
+const fidl_type_t v1_example_EnumUint8Table = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint8, .validate=&EnumValidatorFor_v1_example_EnumUint8, .name="example/EnumUint8"}}};
+
+static bool EnumValidatorFor_v1_example_EnumUint32(uint64_t v) { return (v == 842084399ul) || false; }
+const fidl_type_t v1_example_EnumUint32Table = {.type_tag=kFidlTypeEnum, {.coded_enum={.underlying_type=kFidlCodedPrimitive_Uint32, .validate=&EnumValidatorFor_v1_example_EnumUint32, .name="example/EnumUint32"}}};
+
+static const struct FidlStructField Fields22v1_example_Regression5[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=1u, .padding=3u},
+ /*FidlStructField*/{.type=&v1_example_EnumUint32Table, .offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_example_EnumUint8Table, .offset=8u, .padding=1u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=12u, .padding=4u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=25u, .padding=7u}
+};
+const fidl_type_t v1_example_Regression5Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields22v1_example_Regression5, .field_count=6u, .size=32u, .max_out_of_line=0u, .contains_union=false, .name="example/Regression5", .alt_type=&example_Regression5Table}}};
+
+static const struct FidlStructField Fields22v1_example_EmptyStruct[] = {};
+const fidl_type_t v1_example_EmptyStructTable = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields22v1_example_EmptyStruct, .field_count=0u, .size=1u, .max_out_of_line=0u, .contains_union=false, .name="example/EmptyStruct", .alt_type=&example_EmptyStructTable}}};
+
+const fidl_type_t v1_example_BitsUint8Table = {.type_tag=kFidlTypeBits, {.coded_bits={.underlying_type=kFidlCodedPrimitive_Uint8, .mask=8ul, .name="example/BitsUint8"}}};
+
+const fidl_type_t v1_example_BitsUint32Table = {.type_tag=kFidlTypeBits, {.coded_bits={.underlying_type=kFidlCodedPrimitive_Uint32, .mask=805306371ul, .name="example/BitsUint32"}}};
+
+static const struct FidlStructField Fields22v1_example_Regression6[] = {
+ /*FidlStructField*/{.type=NULL, .padding_offset=1u, .padding=3u},
+ /*FidlStructField*/{.type=&v1_example_BitsUint32Table, .offset=4u, .padding=0u},
+ /*FidlStructField*/{.type=&v1_example_BitsUint8Table, .offset=8u, .padding=1u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=12u, .padding=4u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=24u, .padding=0u},
+ /*FidlStructField*/{.type=NULL, .padding_offset=25u, .padding=7u}
+};
+const fidl_type_t v1_example_Regression6Table = {.type_tag=kFidlTypeStruct, {.coded_struct={.fields=Fields22v1_example_Regression6, .field_count=6u, .size=32u, .max_out_of_line=0u, .contains_union=false, .name="example/Regression6", .alt_type=&example_Regression6Table}}};
+
diff --git a/zircon/system/utest/fidl/llcpp_transaction_tests.cc b/zircon/system/utest/fidl/llcpp_transaction_tests.cc
index a6dc0b7..f3b29f3 100644
--- a/zircon/system/utest/fidl/llcpp_transaction_tests.cc
+++ b/zircon/system/utest/fidl/llcpp_transaction_tests.cc
@@ -10,10 +10,10 @@
#include <limits.h>
#include <zircon/syscalls.h>
-#include <fidl/test/coding/llcpp/fidl.h>
#include <unittest/unittest.h>
#include "fidl_coded_types.h"
+#include "generated/fidl_llcpp_llcpp.test.h"
namespace {
diff --git a/zircon/system/utest/fidl/transformer_tests.c b/zircon/system/utest/fidl/transformer_tests.c
index a9bceb3..dc98841 100644
--- a/zircon/system/utest/fidl/transformer_tests.c
+++ b/zircon/system/utest/fidl/transformer_tests.c
@@ -6,22 +6,12 @@
#include <stdio.h>
#include <string.h>
-#include <example/c/fidl.h>
#include <unittest/unittest.h>
+#include "generated/transformer_tables.test.h"
#include "zircon/errors.h"
#include "zircon/types.h"
-// Extra tables not mentioned in the C bindings header but used in these tests.
-extern const fidl_type_t v1_example_Sandwich6Table;
-extern const fidl_type_t example_Sandwich6Table;
-extern const fidl_type_t example_Sandwich1Table;
-extern const fidl_type_t v1_example_Regression5Table;
-extern const fidl_type_t example_Regression5Table;
-extern const fidl_type_t v1_example_Regression6Table;
-extern const fidl_type_t example_Regression6Table;
-extern const fidl_type_t v1_example_FakeProtocolSendFakeLauncherCreateComponentRequestRequestTable;
-
#define ASSERT_TRUE_NOMSG(x) ASSERT_TRUE(x, "")
bool cmp_payload(const uint8_t* actual, size_t actual_size, const uint8_t* expected,
diff --git a/zircon/system/utest/service/BUILD.gn b/zircon/system/utest/service/BUILD.gn
index fbb7f64..23b5d14 100644
--- a/zircon/system/utest/service/BUILD.gn
+++ b/zircon/system/utest/service/BUILD.gn
@@ -16,7 +16,7 @@
"llcpp/server_test.cc",
]
deps = [
- ":fidl.service.test.llcpp",
+ ":fidl.service.test-llcpp",
"$zx/system/ulib/async-loop:async-loop-cpp",
"$zx/system/ulib/async-loop:async-loop-default",
"$zx/system/ulib/fdio",
@@ -28,6 +28,18 @@
"$zx/system/ulib/zxtest",
]
}
+
+ # Manually generated LLCPP bindings.
+ source_set("fidl.service.test-llcpp") {
+ testonly = true
+ sources = [ "generated/fidl_llcpp_test.test.cc" ]
+ include_dirs = [ "generated" ]
+ deps = [
+ ":fidl.service.test.c",
+ "$zx/system/ulib/fidl:fidl-llcpp",
+ ]
+ public_deps = [ "$zx/system/ulib/fidl:fidl-llcpp.headers" ]
+ }
}
# Generate C bindings that the LLCPP bindings depend on.
diff --git a/zircon/system/utest/service/gen_llcpp.sh b/zircon/system/utest/service/gen_llcpp.sh
new file mode 100755
index 0000000..edd98e7
--- /dev/null
+++ b/zircon/system/utest/service/gen_llcpp.sh
@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+
+set -eu
+set -o pipefail
+
+LLCPP_TEST_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+FUCHSIA_DIR="$( echo ${LLCPP_TEST_DIR} | sed -e 's,zircon/system/utest.*$,,' )"
+
+if [ -z ${FUCHSIA_BUILD_DIR+x} ]; then
+ echo "please use fx exec to run this script" 1>&2
+ exit 1
+fi
+
+FIDLC=${FUCHSIA_BUILD_DIR}/host_x64/fidlc
+FIDLGEN=${FUCHSIA_BUILD_DIR}/host_x64/fidlgen_llcpp
+
+if [ ! -x "${FIDLC}" ]; then
+ echo "error: fidlc missing; did you fx clean-build?" 1>&2
+ exit 1
+fi
+
+if [ ! -x "${FIDLGEN}" ]; then
+ echo "error: fidlgen_llcpp missing; did you fx clean-build?" 1>&2
+ exit 1
+fi
+
+cd ${FUCHSIA_DIR}
+
+for src_path in `find "${LLCPP_TEST_DIR}" -name '*.fidl'`; do
+ src_name="$( basename "${src_path}" .fidl )"
+ json_name=${src_name}.json
+
+ # generate the json IR
+ cd ${LLCPP_TEST_DIR}
+ ${FIDLC} --json /tmp/${json_name} \
+ --files ${src_path}
+
+ # generate llcpp bindings
+ ${FIDLGEN} -json /tmp/${json_name} \
+ -header fidl_llcpp_${src_name}.h \
+ -source fidl_llcpp_${src_name}.cc \
+ -include-base .
+
+ # move bindings to the `generated` directory
+ mv fidl_llcpp_${src_name}.h ${LLCPP_TEST_DIR}/generated
+ mv fidl_llcpp_${src_name}.cc ${LLCPP_TEST_DIR}/generated
+
+ # cleanup
+ rm /tmp/${json_name}
+done
diff --git a/zircon/system/utest/service/generated/fidl_llcpp_test.test.cc b/zircon/system/utest/service/generated/fidl_llcpp_test.test.cc
new file mode 100644
index 0000000..8f1d4ca
--- /dev/null
+++ b/zircon/system/utest/service/generated/fidl_llcpp_test.test.cc
@@ -0,0 +1,192 @@
+// WARNING: This file is machine generated by fidlgen.
+
+#include <fidl_llcpp_test.test.h>
+#include <memory>
+
+namespace llcpp {
+
+namespace fidl {
+namespace service {
+namespace test {
+
+namespace {
+
+[[maybe_unused]]
+constexpr uint64_t kEcho_EchoString_Ordinal = 0x503b9f2a00000000lu;
+[[maybe_unused]]
+constexpr uint64_t kEcho_EchoString_GenOrdinal = 0xd966a2bafde7462lu;
+extern "C" const fidl_type_t fidl_service_test_EchoEchoStringRequestTable;
+extern "C" const fidl_type_t fidl_service_test_EchoEchoStringResponseTable;
+extern "C" const fidl_type_t v1_fidl_service_test_EchoEchoStringResponseTable;
+
+} // namespace
+template <>
+Echo::ResultOf::EchoString_Impl<Echo::EchoStringResponse>::EchoString_Impl(::zx::unowned_channel _client_end, ::fidl::StringView value) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EchoStringRequest, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr _write_bytes_boxed = std::make_unique<::fidl::internal::AlignedBuffer<_kWriteAllocSize>>();
+ auto& _write_bytes_array = *_write_bytes_boxed;
+ EchoStringRequest _request = {};
+ _request.value = std::move(value);
+ auto _linearize_result = ::fidl::Linearize(&_request, _write_bytes_array.view());
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EchoStringRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Echo::InPlace::EchoString(std::move(_client_end), std::move(_decoded_request), Super::response_buffer()));
+}
+
+Echo::ResultOf::EchoString Echo::SyncClient::EchoString(::fidl::StringView value) {
+ return ResultOf::EchoString(::zx::unowned_channel(this->channel_), std::move(value));
+}
+
+Echo::ResultOf::EchoString Echo::Call::EchoString(::zx::unowned_channel _client_end, ::fidl::StringView value) {
+ return ResultOf::EchoString(std::move(_client_end), std::move(value));
+}
+
+template <>
+Echo::UnownedResultOf::EchoString_Impl<Echo::EchoStringResponse>::EchoString_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView value, ::fidl::BytePart _response_buffer) {
+ if (_request_buffer.capacity() < EchoStringRequest::PrimarySize) {
+ Super::SetFailure(::fidl::DecodeResult<EchoStringResponse>(ZX_ERR_BUFFER_TOO_SMALL, ::fidl::internal::kErrorRequestBufferTooSmall));
+ return;
+ }
+ EchoStringRequest _request = {};
+ _request.value = std::move(value);
+ auto _linearize_result = ::fidl::Linearize(&_request, std::move(_request_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ Super::SetFailure(std::move(_linearize_result));
+ return;
+ }
+ ::fidl::DecodedMessage<EchoStringRequest> _decoded_request = std::move(_linearize_result.message);
+ Super::SetResult(
+ Echo::InPlace::EchoString(std::move(_client_end), std::move(_decoded_request), std::move(_response_buffer)));
+}
+
+Echo::UnownedResultOf::EchoString Echo::SyncClient::EchoString(::fidl::BytePart _request_buffer, ::fidl::StringView value, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EchoString(::zx::unowned_channel(this->channel_), std::move(_request_buffer), std::move(value), std::move(_response_buffer));
+}
+
+Echo::UnownedResultOf::EchoString Echo::Call::EchoString(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView value, ::fidl::BytePart _response_buffer) {
+ return UnownedResultOf::EchoString(std::move(_client_end), std::move(_request_buffer), std::move(value), std::move(_response_buffer));
+}
+
+::fidl::DecodeResult<Echo::EchoStringResponse> Echo::InPlace::EchoString(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EchoStringRequest> params, ::fidl::BytePart response_buffer) {
+ Echo::SetTransactionHeaderFor::EchoStringRequest(params);
+ auto _encode_request_result = ::fidl::Encode(std::move(params));
+ if (_encode_request_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Echo::EchoStringResponse>::FromFailure(
+ std::move(_encode_request_result));
+ }
+ auto _call_result = ::fidl::Call<EchoStringRequest, EchoStringResponse>(
+ std::move(_client_end), std::move(_encode_request_result.message), std::move(response_buffer));
+ if (_call_result.status != ZX_OK) {
+ return ::fidl::DecodeResult<Echo::EchoStringResponse>::FromFailure(
+ std::move(_call_result));
+ }
+ return ::fidl::Decode(std::move(_call_result.message));
+}
+
+
+bool Echo::TryDispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ if (msg->num_bytes < sizeof(fidl_message_header_t)) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ fidl_message_header_t* hdr = reinterpret_cast<fidl_message_header_t*>(msg->bytes);
+ zx_status_t status = fidl_validate_txn_header(hdr);
+ if (status != ZX_OK) {
+ txn->Close(status);
+ return true;
+ }
+ switch (hdr->ordinal) {
+ case kEcho_EchoString_Ordinal:
+ case kEcho_EchoString_GenOrdinal:
+ {
+ auto result = ::fidl::DecodeAs<EchoStringRequest>(msg);
+ if (result.status != ZX_OK) {
+ txn->Close(ZX_ERR_INVALID_ARGS);
+ return true;
+ }
+ auto message = result.message.message();
+ impl->EchoString(std::move(message->value),
+ Interface::EchoStringCompleter::Sync(txn));
+ return true;
+ }
+ default: {
+ return false;
+ }
+ }
+}
+
+bool Echo::Dispatch(Interface* impl, fidl_msg_t* msg, ::fidl::Transaction* txn) {
+ bool found = TryDispatch(impl, msg, txn);
+ if (!found) {
+ zx_handle_close_many(msg->handles, msg->num_handles);
+ txn->Close(ZX_ERR_NOT_SUPPORTED);
+ }
+ return found;
+}
+
+
+void Echo::Interface::EchoStringCompleterBase::Reply(::fidl::StringView response) {
+ constexpr uint32_t _kWriteAllocSize = ::fidl::internal::ClampedMessageSize<EchoStringResponse, ::fidl::MessageDirection::kSending>();
+ std::unique_ptr<uint8_t[]> _write_bytes_unique_ptr(new uint8_t[_kWriteAllocSize]);
+ uint8_t* _write_bytes = _write_bytes_unique_ptr.get();
+ EchoStringResponse _response = {};
+ Echo::SetTransactionHeaderFor::EchoStringResponse(
+ ::fidl::DecodedMessage<EchoStringResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EchoStringResponse::PrimarySize,
+ EchoStringResponse::PrimarySize)));
+ _response.response = std::move(response);
+ auto _linearize_result = ::fidl::Linearize(&_response, ::fidl::BytePart(_write_bytes,
+ _kWriteAllocSize));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Echo::Interface::EchoStringCompleterBase::Reply(::fidl::BytePart _buffer, ::fidl::StringView response) {
+ if (_buffer.capacity() < EchoStringResponse::PrimarySize) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ EchoStringResponse _response = {};
+ Echo::SetTransactionHeaderFor::EchoStringResponse(
+ ::fidl::DecodedMessage<EchoStringResponse>(
+ ::fidl::BytePart(reinterpret_cast<uint8_t*>(&_response),
+ EchoStringResponse::PrimarySize,
+ EchoStringResponse::PrimarySize)));
+ _response.response = std::move(response);
+ auto _linearize_result = ::fidl::Linearize(&_response, std::move(_buffer));
+ if (_linearize_result.status != ZX_OK) {
+ CompleterBase::Close(ZX_ERR_INTERNAL);
+ return;
+ }
+ CompleterBase::SendReply(std::move(_linearize_result.message));
+}
+
+void Echo::Interface::EchoStringCompleterBase::Reply(::fidl::DecodedMessage<EchoStringResponse> params) {
+ Echo::SetTransactionHeaderFor::EchoStringResponse(params);
+ CompleterBase::SendReply(std::move(params));
+}
+
+
+
+void Echo::SetTransactionHeaderFor::EchoStringRequest(const ::fidl::DecodedMessage<Echo::EchoStringRequest>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kEcho_EchoString_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+void Echo::SetTransactionHeaderFor::EchoStringResponse(const ::fidl::DecodedMessage<Echo::EchoStringResponse>& _msg) {
+ fidl_init_txn_header(&_msg.message()->_hdr, 0, kEcho_EchoString_GenOrdinal);
+ _msg.message()->_hdr.flags[0] |= FIDL_TXN_HEADER_UNION_FROM_XUNION_FLAG;
+}
+
+} // namespace test
+} // namespace service
+} // namespace fidl
+} // namespace llcpp
diff --git a/zircon/system/utest/service/generated/fidl_llcpp_test.test.h b/zircon/system/utest/service/generated/fidl_llcpp_test.test.h
new file mode 100644
index 0000000..5dbd5044
--- /dev/null
+++ b/zircon/system/utest/service/generated/fidl_llcpp_test.test.h
@@ -0,0 +1,351 @@
+// 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 <zircon/fidl.h>
+
+namespace llcpp {
+
+namespace fidl {
+namespace service {
+namespace test {
+
+class Echo;
+class EchoService;
+
+extern "C" const fidl_type_t fidl_service_test_EchoEchoStringRequestTable;
+extern "C" const fidl_type_t v1_fidl_service_test_EchoEchoStringRequestTable;
+extern "C" const fidl_type_t fidl_service_test_EchoEchoStringResponseTable;
+extern "C" const fidl_type_t v1_fidl_service_test_EchoEchoStringResponseTable;
+
+class Echo final {
+ Echo() = delete;
+ public:
+
+ struct EchoStringResponse final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView response;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_service_test_EchoEchoStringResponseTable;
+ static constexpr const fidl_type_t* AltType = &fidl_service_test_EchoEchoStringResponseTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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 EchoStringRequest final {
+ FIDL_ALIGNDECL
+ fidl_message_header_t _hdr;
+ ::fidl::StringView value;
+
+ static constexpr const fidl_type_t* Type = &v1_fidl_service_test_EchoEchoStringRequestTable;
+ static constexpr const fidl_type_t* AltType = &fidl_service_test_EchoEchoStringRequestTable;
+ static constexpr uint32_t MaxNumHandles = 0;
+ static constexpr uint32_t PrimarySize = 32;
+ static constexpr uint32_t MaxOutOfLine = 4294967295;
+ static constexpr uint32_t AltPrimarySize = 32;
+ static constexpr uint32_t AltMaxOutOfLine = 4294967295;
+ 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 = EchoStringResponse;
+ };
+
+
+ // Collection of return types of FIDL calls in this interface.
+ class ResultOf final {
+ ResultOf() = delete;
+ private:
+ template <typename ResponseType>
+ class EchoString_Impl final : private ::fidl::internal::OwnedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::OwnedSyncCallBase<ResponseType>;
+ public:
+ EchoString_Impl(::zx::unowned_channel _client_end, ::fidl::StringView value);
+ ~EchoString_Impl() = default;
+ EchoString_Impl(EchoString_Impl&& other) = default;
+ EchoString_Impl& operator=(EchoString_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 EchoString = EchoString_Impl<EchoStringResponse>;
+ };
+
+ // 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 EchoString_Impl final : private ::fidl::internal::UnownedSyncCallBase<ResponseType> {
+ using Super = ::fidl::internal::UnownedSyncCallBase<ResponseType>;
+ public:
+ EchoString_Impl(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView value, ::fidl::BytePart _response_buffer);
+ ~EchoString_Impl() = default;
+ EchoString_Impl(EchoString_Impl&& other) = default;
+ EchoString_Impl& operator=(EchoString_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 EchoString = EchoString_Impl<EchoStringResponse>;
+ };
+
+ 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_; }
+
+ // Request is heap-allocated. Response is heap-allocated.
+ ResultOf::EchoString EchoString(::fidl::StringView value);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ UnownedResultOf::EchoString EchoString(::fidl::BytePart _request_buffer, ::fidl::StringView value, ::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:
+
+ // Request is heap-allocated. Response is heap-allocated.
+ static ResultOf::EchoString EchoString(::zx::unowned_channel _client_end, ::fidl::StringView value);
+
+ // Caller provides the backing storage for FIDL message via request and response buffers.
+ static UnownedResultOf::EchoString EchoString(::zx::unowned_channel _client_end, ::fidl::BytePart _request_buffer, ::fidl::StringView value, ::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<EchoStringResponse> EchoString(::zx::unowned_channel _client_end, ::fidl::DecodedMessage<EchoStringRequest> params, ::fidl::BytePart response_buffer);
+
+ };
+
+ // Pure-virtual interface to be implemented by a server.
+ class Interface {
+ public:
+ Interface() = default;
+ virtual ~Interface() = default;
+ using _Outer = Echo;
+ using _Base = ::fidl::CompleterBase;
+
+ class EchoStringCompleterBase : public _Base {
+ public:
+ void Reply(::fidl::StringView response);
+ void Reply(::fidl::BytePart _buffer, ::fidl::StringView response);
+ void Reply(::fidl::DecodedMessage<EchoStringResponse> params);
+
+ protected:
+ using ::fidl::CompleterBase::CompleterBase;
+ };
+
+ using EchoStringCompleter = ::fidl::Completer<EchoStringCompleterBase>;
+
+ virtual void EchoString(::fidl::StringView value, EchoStringCompleter::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 EchoStringRequest(const ::fidl::DecodedMessage<Echo::EchoStringRequest>& _msg);
+ static void EchoStringResponse(const ::fidl::DecodedMessage<Echo::EchoStringResponse>& _msg);
+ };
+};
+
+// A service that provides multiple Echo implementations.
+class EchoService final {
+ EchoService() = default;
+ public:
+ static constexpr char Name[] = "fidl.service.test.EchoService";
+
+ // Client interface for connecting to member protocols of a service instance.
+ class ServiceClient final {
+ ServiceClient() = delete;
+ public:
+ ServiceClient(::zx::channel dir, ::fidl::internal::ConnectMemberFunc connect_func)
+ : dir_(std::move(dir)), connect_func_(connect_func) {}
+
+ // Connects to the member protocol "foo". Returns a |fidl::ClientChannel| on
+ // success, which can be used with |fidl::BindSyncClient| to create a synchronous
+ // client.
+ //
+ // # Errors
+ //
+ // On failure, returns a fit::error with zx_status_t != ZX_OK.
+ // Failures can occur if channel creation failed, or if there was an issue making
+ // a |fuchsia.io.Directory::Open| call.
+ //
+ // Since the call to |Open| is asynchronous, an error sent by the remote end will not
+ // result in a failure of this method. Any errors sent by the remote will appear on
+ // the |ClientChannel| returned from this method.
+ ::fidl::result<::fidl::ClientChannel<Echo>> connect_foo() {
+ ::zx::channel local, remote;
+ zx_status_t result = ::zx::channel::create(0, &local, &remote);
+ if (result != ZX_OK) {
+ return ::fit::error(result);
+ }
+ result =
+ connect_func_(::zx::unowned_channel(dir_), ::fidl::StringView("foo"), std::move(remote));
+ if (result != ZX_OK) {
+ return ::fit::error(result);
+ }
+ return ::fit::ok(::fidl::ClientChannel<Echo>(std::move(local)));
+ }
+
+ // Connects to the member protocol "bar". Returns a |fidl::ClientChannel| on
+ // success, which can be used with |fidl::BindSyncClient| to create a synchronous
+ // client.
+ //
+ // # Errors
+ //
+ // On failure, returns a fit::error with zx_status_t != ZX_OK.
+ // Failures can occur if channel creation failed, or if there was an issue making
+ // a |fuchsia.io.Directory::Open| call.
+ //
+ // Since the call to |Open| is asynchronous, an error sent by the remote end will not
+ // result in a failure of this method. Any errors sent by the remote will appear on
+ // the |ClientChannel| returned from this method.
+ ::fidl::result<::fidl::ClientChannel<Echo>> connect_bar() {
+ ::zx::channel local, remote;
+ zx_status_t result = ::zx::channel::create(0, &local, &remote);
+ if (result != ZX_OK) {
+ return ::fit::error(result);
+ }
+ result =
+ connect_func_(::zx::unowned_channel(dir_), ::fidl::StringView("bar"), std::move(remote));
+ if (result != ZX_OK) {
+ return ::fit::error(result);
+ }
+ return ::fit::ok(::fidl::ClientChannel<Echo>(std::move(local)));
+ }
+
+ private:
+ ::zx::channel dir_;
+ ::fidl::internal::ConnectMemberFunc connect_func_;
+ };
+
+ // Facilitates member protocol registration for servers.
+ class Handler final {
+ public:
+ // Constructs a FIDL Service-typed handler. Does not take ownership of |service_handler|.
+ explicit Handler(::llcpp::fidl::ServiceHandlerInterface* service_handler)
+ : service_handler_(service_handler) {}
+
+ // Adds member "foo" to the service instance. |handler| will be invoked on connection
+ // attempts.
+ //
+ // # Errors
+ //
+ // Returns ZX_ERR_ALREADY_EXISTS if the member was already added.
+ zx_status_t add_foo(::llcpp::fidl::ServiceHandlerInterface::MemberHandler handler) {
+ return service_handler_->AddMember("foo", std::move(handler));
+ }
+
+ // Adds member "bar" to the service instance. |handler| will be invoked on connection
+ // attempts.
+ //
+ // # Errors
+ //
+ // Returns ZX_ERR_ALREADY_EXISTS if the member was already added.
+ zx_status_t add_bar(::llcpp::fidl::ServiceHandlerInterface::MemberHandler handler) {
+ return service_handler_->AddMember("bar", std::move(handler));
+ }
+
+ private:
+ ::llcpp::fidl::ServiceHandlerInterface* service_handler_; // Not owned.
+ };
+};
+
+} // namespace test
+} // namespace service
+} // namespace fidl
+} // namespace llcpp
+
+namespace fidl {
+
+template <>
+struct IsFidlType<::llcpp::fidl::service::test::Echo::EchoStringRequest> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::service::test::Echo::EchoStringRequest> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::service::test::Echo::EchoStringRequest)
+ == ::llcpp::fidl::service::test::Echo::EchoStringRequest::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::service::test::Echo::EchoStringRequest, value) == 16);
+
+template <>
+struct IsFidlType<::llcpp::fidl::service::test::Echo::EchoStringResponse> : public std::true_type {};
+template <>
+struct IsFidlMessage<::llcpp::fidl::service::test::Echo::EchoStringResponse> : public std::true_type {};
+static_assert(sizeof(::llcpp::fidl::service::test::Echo::EchoStringResponse)
+ == ::llcpp::fidl::service::test::Echo::EchoStringResponse::PrimarySize);
+static_assert(offsetof(::llcpp::fidl::service::test::Echo::EchoStringResponse, response) == 16);
+
+} // namespace fidl
diff --git a/zircon/system/utest/service/llcpp/client_test.cc b/zircon/system/utest/service/llcpp/client_test.cc
index 5a1825d..78cc2b7 100644
--- a/zircon/system/utest/service/llcpp/client_test.cc
+++ b/zircon/system/utest/service/llcpp/client_test.cc
@@ -8,12 +8,13 @@
#include <lib/service/llcpp/service.h>
#include <lib/zx/channel.h>
-#include <fidl/service/test/llcpp/fidl.h>
#include <fs/pseudo_dir.h>
#include <fs/service.h>
#include <fs/synchronous_vfs.h>
#include <zxtest/zxtest.h>
+#include "../generated/fidl_llcpp_test.test.h"
+
namespace {
using Echo = ::llcpp::fidl::service::test::Echo;
diff --git a/zircon/system/utest/service/llcpp/server_test.cc b/zircon/system/utest/service/llcpp/server_test.cc
index 0b670e8..460c320 100644
--- a/zircon/system/utest/service/llcpp/server_test.cc
+++ b/zircon/system/utest/service/llcpp/server_test.cc
@@ -17,9 +17,10 @@
#include <iostream>
#include <fbl/unique_fd.h>
-#include <fidl/service/test/llcpp/fidl.h>
#include <zxtest/zxtest.h>
+#include "../generated/fidl_llcpp_test.test.h"
+
namespace {
using Echo = ::llcpp::fidl::service::test::Echo;
diff --git a/zircon/tools/fidl/BUILD.gn b/zircon/tools/fidl/BUILD.gn
index 399d666..82238ec 100644
--- a/zircon/tools/fidl/BUILD.gn
+++ b/zircon/tools/fidl/BUILD.gn
@@ -137,7 +137,6 @@
action(target_name) {
script = "build_fidlgen_executable.sh"
-
# go_root, go_path, go_cache must be absolute.
args = [
rebase_path(go_executable, root_build_dir),
